int test_unnormalized_laplacian(igraph_bool_t dir) {
igraph_t g;
igraph_matrix_t m;
igraph_vector_t vec;
igraph_matrix_init(&m, 1, 1);
/* No loop or multiple edges */
igraph_ring(&g, 5, dir, 0, 1);
igraph_laplacian(&g, &m, 0);
print_matrix(&m);
printf("===\n");
/* Add some loop edges */
igraph_vector_init_real(&vec, 4, 1.0, 1.0, 2.0, 2.0);
igraph_add_edges(&g, &vec, 0);
igraph_vector_destroy(&vec);
igraph_laplacian(&g, &m, 0);
print_matrix(&m);
printf("===\n");
/* Duplicate some edges */
igraph_vector_init_real(&vec, 4, 1.0, 2.0, 3.0, 4.0);
igraph_add_edges(&g, &vec, 0);
igraph_vector_destroy(&vec);
igraph_laplacian(&g, &m, 0);
print_matrix(&m);
igraph_destroy(&g);
igraph_matrix_destroy(&m);
return 0;
}
int main(void) {
igraph_real_t avg_path;
igraph_t graph;
igraph_vector_t dimvector;
igraph_vector_t edges;
int i;
igraph_vector_init(&dimvector, 2);
VECTOR(dimvector)[0]=30;
VECTOR(dimvector)[1]=30;
igraph_lattice(&graph, &dimvector, 0, IGRAPH_UNDIRECTED, 0, 1);
igraph_rng_seed(igraph_rng_default(), 42);
igraph_vector_init(&edges, 20);
for (i=0; i<igraph_vector_size(&edges); i++) {
VECTOR(edges)[i] = rand() % (int)igraph_vcount(&graph);
}
igraph_average_path_length(&graph, &avg_path, IGRAPH_UNDIRECTED, 1);
printf("Average path length (lattice): %f\n", (double) avg_path);
igraph_add_edges(&graph, &edges, 0);
igraph_average_path_length(&graph, &avg_path, IGRAPH_UNDIRECTED, 1);
printf("Average path length (randomized lattice): %f\n", (double) avg_path);
igraph_vector_destroy(&dimvector);
igraph_vector_destroy(&edges);
igraph_destroy(&graph);
return 0;
}
int test_normalized_laplacian(igraph_bool_t dir) {
igraph_t g;
igraph_matrix_t m;
igraph_vector_t vec;
igraph_matrix_init(&m, 1, 1);
igraph_bool_t ok = 1;
/* Undirected graph, no loop or multiple edges */
igraph_ring(&g, 5, dir, 0, 1);
igraph_laplacian(&g, &m, 1);
ok = ok && check_laplacian(&g, &m);
/* Add some loop edges */
igraph_vector_init_real(&vec, 4, 1.0, 1.0, 2.0, 2.0);
igraph_add_edges(&g, &vec, 0);
igraph_vector_destroy(&vec);
igraph_laplacian(&g, &m, 1);
ok = ok && check_laplacian(&g, &m);
/* Duplicate some edges */
igraph_vector_init_real(&vec, 4, 1.0, 2.0, 3.0, 4.0);
igraph_add_edges(&g, &vec, 0);
igraph_vector_destroy(&vec);
igraph_laplacian(&g, &m, 1);
ok = ok && check_laplacian(&g, &m);
igraph_destroy(&g);
igraph_matrix_destroy(&m);
if (ok)
printf("OK\n");
return !ok;
}
int igraph_create_bipartite(igraph_t *graph, const igraph_vector_bool_t *types,
const igraph_vector_t *edges,
igraph_bool_t directed) {
igraph_integer_t no_of_nodes=
(igraph_integer_t) igraph_vector_bool_size(types);
long int no_of_edges=igraph_vector_size(edges);
igraph_real_t min_edge=0, max_edge=0;
igraph_bool_t min_type=0, max_type=0;
long int i;
if (no_of_edges % 2 != 0) {
IGRAPH_ERROR("Invalid (odd) edges vector", IGRAPH_EINVEVECTOR);
}
no_of_edges /= 2;
if (no_of_edges != 0) {
igraph_vector_minmax(edges, &min_edge, &max_edge);
}
if (min_edge < 0 || max_edge >= no_of_nodes) {
IGRAPH_ERROR("Invalid (negative) vertex id", IGRAPH_EINVVID);
}
/* Check types vector */
if (no_of_nodes != 0) {
igraph_vector_bool_minmax(types, &min_type, &max_type);
if (min_type < 0 || max_type > 1) {
IGRAPH_WARNING("Non-binary type vector when creating a bipartite graph");
}
}
/* Check bipartiteness */
for (i=0; i<no_of_edges*2; i+=2) {
long int from=(long int) VECTOR(*edges)[i];
long int to=(long int) VECTOR(*edges)[i+1];
long int t1=VECTOR(*types)[from];
long int t2=VECTOR(*types)[to];
if ( (t1 && t2) || (!t1 && !t2) ) {
IGRAPH_ERROR("Invalid edges, not a bipartite graph", IGRAPH_EINVAL);
}
}
IGRAPH_CHECK(igraph_empty(graph, no_of_nodes, directed));
IGRAPH_FINALLY(igraph_destroy, graph);
IGRAPH_CHECK(igraph_add_edges(graph, edges, 0));
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int main(int argc, char **argv) {
unsigned int i;
for (i=0; i<1000; ++i) {
igraph_t graph;
igraph_vector_t edges;
igraph_empty(&graph, 1001, 0);
igraph_vector_init(&edges, 2000);
igraph_add_edges(&graph, &edges, NULL);
igraph_destroy(&graph);
igraph_vector_destroy(&edges);
}
return 0;
}
void Graph::addEdges(const Vector& edges) {
assert(m_pGraph);
IGRAPH_TRY(igraph_add_edges(m_pGraph, edges.c_vector(), 0));
}
igraph_vector_t * ggen_analyze_longest_antichain(igraph_t *g)
{
/* The following steps are implemented :
* - Convert our DAG to a specific bipartite graph B
* - solve maximum matching on B
* - conver maximum matching to min vectex cover
* - convert min vertex cover to antichain on G
*/
int err;
unsigned long i,vg,found,added;
igraph_t b,gstar;
igraph_vector_t edges,*res = NULL;
igraph_vector_t c,s,t,todo,n,next,l,r;
igraph_eit_t eit;
igraph_es_t es;
igraph_integer_t from,to;
igraph_vit_t vit;
igraph_vs_t vs;
igraph_real_t value;
if(g == NULL)
return NULL;
/* before creating the bipartite graph, we need all relations
* between any two vertices : the transitive closure of g */
err = igraph_copy(&gstar,g);
if(err) return NULL;
err = ggen_transform_transitive_closure(&gstar);
if(err) goto error;
/* Bipartite convertion : let G = (S,C),
* we build B = (U,V,E) with
* - U = V = S (each vertex is present twice)
* - (u,v) \in E iff :
* - u \in U
* - v \in V
* - u < v in C (warning, this means that we take
* transitive closure into account, not just the
* original edges)
* We will also need two additional nodes further in the code.
*/
vg = igraph_vcount(g);
err = igraph_empty(&b,vg*2,1);
if(err) goto error;
/* id and id+vg will be a vertex in U and its copy in V,
* iterate over gstar edges to create edges in b
*/
err = igraph_vector_init(&edges,igraph_ecount(&gstar));
if(err) goto d_b;
igraph_vector_clear(&edges);
err = igraph_eit_create(&gstar,igraph_ess_all(IGRAPH_EDGEORDER_ID),&eit);
if(err) goto d_edges;
for(IGRAPH_EIT_RESET(eit); !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit))
{
err = igraph_edge(&gstar,IGRAPH_EIT_GET(eit),&from,&to);
if(err)
{
igraph_eit_destroy(&eit);
goto d_edges;
}
to += vg;
igraph_vector_push_back(&edges,(igraph_real_t)from);
igraph_vector_push_back(&edges,(igraph_real_t)to);
}
igraph_eit_destroy(&eit);
err = igraph_add_edges(&b,&edges,NULL);
if(err) goto d_edges;
/* maximum matching on b */
igraph_vector_clear(&edges);
err = bipartite_maximum_matching(&b,&edges);
if(err) goto d_edges;
/* Let M be the max matching, and N be E - M
* Define T as all unmatched vectices from U as well as all vertices
* reachable from those by going left-to-right along N and right-to-left along
* M.
* Define L = U - T, R = V \inter T
* C:= L + R
* C is a minimum vertex cover
*/
err = igraph_vector_init_seq(&n,0,igraph_ecount(&b)-1);
if(err) goto d_edges;
err = vector_diff(&n,&edges);
if(err) goto d_n;
err = igraph_vector_init(&c,vg);
if(err) goto d_n;
igraph_vector_clear(&c);
/* matched vertices : S */
err = igraph_vector_init(&s,vg);
if(err) goto d_c;
igraph_vector_clear(&s);
for(i = 0; i < igraph_vector_size(&edges); i++)
{
err = igraph_edge(&b,VECTOR(edges)[i],&from,&to);
if(err) goto d_s;
igraph_vector_push_back(&s,from);
}
/* we may have inserted the same vertex multiple times */
err = vector_uniq(&s);
if(err) goto d_s;
/* unmatched */
err = igraph_vector_init_seq(&t,0,vg-1);
if(err) goto d_s;
err = vector_diff(&t,&s);
if(err) goto d_t;
/* alternating paths
*/
err = igraph_vector_copy(&todo,&t);
if(err) goto d_t;
err = igraph_vector_init(&next,vg);
if(err) goto d_todo;
igraph_vector_clear(&next);
do {
vector_uniq(&todo);
added = 0;
for(i = 0; i < igraph_vector_size(&todo); i++)
{
if(VECTOR(todo)[i] < vg)
{
/* scan edges */
err = igraph_es_adj(&es,VECTOR(todo)[i],IGRAPH_OUT);
if(err) goto d_next;
err = igraph_eit_create(&b,es,&eit);
if(err)
{
igraph_es_destroy(&es);
goto d_next;
}
for(IGRAPH_EIT_RESET(eit); !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit))
{
if(igraph_vector_binsearch(&n,IGRAPH_EIT_GET(eit),NULL))
{
err = igraph_edge(&b,IGRAPH_EIT_GET(eit),&from,&to);
if(err)
{
igraph_eit_destroy(&eit);
igraph_es_destroy(&es);
goto d_next;
}
if(!igraph_vector_binsearch(&t,to,NULL))
{
igraph_vector_push_back(&next,to);
added = 1;
}
}
}
}
else
{
/* scan edges */
err = igraph_es_adj(&es,VECTOR(todo)[i],IGRAPH_IN);
if(err) goto d_next;
err = igraph_eit_create(&b,es,&eit);
if(err)
{
igraph_es_destroy(&es);
goto d_next;
}
for(IGRAPH_EIT_RESET(eit); !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit))
{
if(igraph_vector_binsearch(&edges,IGRAPH_EIT_GET(eit),NULL))
{
err = igraph_edge(&b,IGRAPH_EIT_GET(eit),&from,&to);
if(err)
{
igraph_eit_destroy(&eit);
igraph_es_destroy(&es);
goto d_next;
}
if(!igraph_vector_binsearch(&t,to,NULL))
{
igraph_vector_push_back(&next,from);
added = 1;
}
}
}
}
igraph_es_destroy(&es);
igraph_eit_destroy(&eit);
}
igraph_vector_append(&t,&todo);
igraph_vector_clear(&todo);
igraph_vector_append(&todo,&next);
igraph_vector_clear(&next);
} while(added);
err = igraph_vector_init_seq(&l,0,vg-1);
if(err) goto d_t;
err = vector_diff(&l,&t);
if(err) goto d_l;
err = igraph_vector_update(&c,&l);
if(err) goto d_l;
err = igraph_vector_init(&r,vg);
if(err) goto d_l;
igraph_vector_clear(&r);
/* compute V \inter T */
for(i = 0; i < igraph_vector_size(&t); i++)
{
if(VECTOR(t)[i] >= vg)
igraph_vector_push_back(&r,VECTOR(t)[i]);
}
igraph_vector_add_constant(&r,(igraph_real_t)-vg);
err = vector_union(&c,&r);
if(err) goto d_r;
/* our antichain is U - C */
res = malloc(sizeof(igraph_vector_t));
if(res == NULL) goto d_r;
err = igraph_vector_init_seq(res,0,vg-1);
if(err) goto f_res;
err = vector_diff(res,&c);
if(err) goto d_res;
goto ret;
d_res:
igraph_vector_destroy(res);
f_res:
free(res);
res = NULL;
ret:
d_r:
igraph_vector_destroy(&r);
d_l:
igraph_vector_destroy(&l);
d_next:
igraph_vector_destroy(&next);
d_todo:
igraph_vector_destroy(&todo);
d_t:
igraph_vector_destroy(&t);
d_s:
igraph_vector_destroy(&s);
d_c:
igraph_vector_destroy(&c);
d_n:
igraph_vector_destroy(&n);
d_edges:
igraph_vector_destroy(&edges);
d_b:
igraph_destroy(&b);
error:
igraph_destroy(&gstar);
return res;
}
int test_unnormalized_laplacian(igraph_vector_t* w, igraph_bool_t dir) {
igraph_t g;
igraph_matrix_t m, m2;
igraph_sparsemat_t sm;
igraph_vector_t vec, *weights = 0;
igraph_matrix_init(&m, 1, 1);
igraph_sparsemat_init(&sm, 0, 0, 0);
if (w) {
weights = (igraph_vector_t*)calloc(1, sizeof(igraph_vector_t));
igraph_vector_copy(weights, w);
}
/* No loop or multiple edges */
igraph_ring(&g, 5, dir, 0, 1);
igraph_laplacian(&g, &m, &sm, 0, weights);
igraph_matrix_init(&m2, 0, 0);
igraph_sparsemat_as_matrix(&m2, &sm);
if (!igraph_matrix_all_e_tol(&m, &m2, 0)) {
return 41;
}
igraph_matrix_destroy(&m2);
igraph_matrix_print(&m);
printf("===\n");
/* Add some loop edges */
igraph_vector_init_real(&vec, 4, 1.0, 1.0, 2.0, 2.0);
igraph_add_edges(&g, &vec, 0);
igraph_vector_destroy(&vec);
if (weights) {
igraph_vector_push_back(weights, 2);
igraph_vector_push_back(weights, 2);
}
igraph_laplacian(&g, &m, &sm, 0, weights);
igraph_matrix_init(&m2, 0, 0);
igraph_sparsemat_as_matrix(&m2, &sm);
if (!igraph_matrix_all_e_tol(&m, &m2, 0)) {
return 42;
}
igraph_matrix_destroy(&m2);
igraph_matrix_print(&m);
printf("===\n");
/* Duplicate some edges */
igraph_vector_init_real(&vec, 4, 1.0, 2.0, 3.0, 4.0);
igraph_add_edges(&g, &vec, 0);
igraph_vector_destroy(&vec);
if (weights) {
igraph_vector_push_back(weights, 3);
igraph_vector_push_back(weights, 3);
}
igraph_laplacian(&g, &m, &sm, 0, weights);
igraph_matrix_init(&m2, 0, 0);
igraph_sparsemat_as_matrix(&m2, &sm);
if (!igraph_matrix_all_e_tol(&m, &m2, 0)) {
return 43;
}
igraph_matrix_destroy(&m2);
igraph_matrix_print(&m);
igraph_destroy(&g);
igraph_matrix_destroy(&m);
if (weights) {
igraph_vector_destroy(weights); free(weights);
}
return 0;
}
int test_normalized_laplacian(igraph_vector_t *w, igraph_bool_t dir) {
igraph_t g;
igraph_matrix_t m, m2;
igraph_sparsemat_t sm;
igraph_vector_t vec, *weights = 0;
igraph_bool_t ok = 1;
igraph_matrix_init(&m, 1, 1);
igraph_sparsemat_init(&sm, 0, 0, 0);
if (w) {
weights = (igraph_vector_t*)calloc(1, sizeof(igraph_vector_t));
igraph_vector_copy(weights, w);
}
/* Undirected graph, no loop or multiple edges */
igraph_ring(&g, 5, dir, 0, 1);
igraph_laplacian(&g, &m, &sm, 1, weights);
igraph_matrix_init(&m2, 0, 0);
igraph_sparsemat_as_matrix(&m2, &sm);
if (!igraph_matrix_all_e_tol(&m, &m2, 0)) {
return 44;
}
igraph_matrix_destroy(&m2);
ok = ok && check_laplacian(&g, &m, weights);
/* Add some loop edges */
igraph_vector_init_real(&vec, 4, 1.0, 1.0, 2.0, 2.0);
igraph_add_edges(&g, &vec, 0);
igraph_vector_destroy(&vec);
if (weights) {
igraph_vector_push_back(weights, 2);
igraph_vector_push_back(weights, 2);
}
igraph_laplacian(&g, &m, &sm, 1, weights);
igraph_matrix_init(&m2, 0, 0);
igraph_sparsemat_as_matrix(&m2, &sm);
if (!igraph_matrix_all_e_tol(&m, &m2, 0)) {
return 45;
}
igraph_matrix_destroy(&m2);
ok = ok && check_laplacian(&g, &m, weights);
/* Duplicate some edges */
igraph_vector_init_real(&vec, 4, 1.0, 2.0, 3.0, 4.0);
igraph_add_edges(&g, &vec, 0);
igraph_vector_destroy(&vec);
if (weights) {
igraph_vector_push_back(weights, 3);
igraph_vector_push_back(weights, 3);
}
igraph_laplacian(&g, &m, &sm, 1, weights);
igraph_matrix_init(&m2, 0, 0);
igraph_sparsemat_as_matrix(&m2, &sm);
if (!igraph_matrix_all_e_tol(&m, &m2, 0)) {
return 46;
}
igraph_matrix_destroy(&m2);
ok = ok && check_laplacian(&g, &m, weights);
igraph_destroy(&g);
igraph_matrix_destroy(&m);
if (weights) {
igraph_vector_destroy(weights); free(weights);
}
if (ok)
printf("OK\n");
return !ok;
}
int ggen_read_graph(igraph_t *g,FILE *input)
{
Agraph_t *cg;
Agnode_t *v;
Agedge_t *e;
igraph_vector_t edges;
igraph_vector_t vertices;
int err;
unsigned long esize;
unsigned long vsize;
unsigned long from, to;
igraph_integer_t eid;
Agsym_t *att;
/* read the graph */
cg = agread((void *)input,NULL);
if(!cg) return 1;
if(!agisdirected(cg))
{
error("Input graph is undirected\n");
err = 1;
goto error_d;
}
/* init edge array */
err = igraph_vector_init(&edges,2*agnedges(cg));
if(err) goto error_d;
err = igraph_vector_init(&vertices,agnnodes(cg));
if(err) goto error_de;
/* init igraph */
igraph_empty(g,agnnodes(cg),1);
/* asign id to each vertex */
vsize = 0;
for(v = agfstnode(cg); v; v = agnxtnode(cg,v))
VECTOR(vertices)[vsize++] = AGID(v);
/* loop through each edge */
esize = 0;
for(v = agfstnode(cg); v; v = agnxtnode(cg,v))
{
from = find_id(AGID(v),vertices,vsize);
for(e = agfstout(cg,v); e; e = agnxtout(cg,e))
{
to = find_id(AGID(aghead(e)),vertices,vsize);
VECTOR(edges)[esize++] = from;
VECTOR(edges)[esize++] = to;
}
}
/* finish the igraph */
err = igraph_add_edges(g,&edges,NULL);
if(err) goto error;
/* read graph properties */
att = agnxtattr(cg,AGRAPH,NULL);
while(att != NULL)
{
/* copy this attribute to igraph */
SETGAS(g,att->name,agxget(cg,att));
att = agnxtattr(cg,AGRAPH,att);
}
/* we keep the graph name using a special attribute */
SETGAS(g,GGEN_GRAPH_NAME_ATTR,agnameof(cg));
/* read vertex properties */
att = agnxtattr(cg,AGNODE,NULL);
while(att != NULL)
{
/* iterate over all vertices for this attribute */
for(v = agfstnode(cg); v; v = agnxtnode(cg,v))
{
from = find_id(AGID(v),vertices,vsize);
SETVAS(g,att->name,from,agxget(v,att));
}
att = agnxtattr(cg,AGNODE,att);
}
/* we keep each vertex name in a special attribute */
for(v = agfstnode(cg); v; v = agnxtnode(cg,v))
{
from = find_id(AGID(v),vertices,vsize);
SETVAS(g,GGEN_VERTEX_NAME_ATTR,from,agnameof(v));
}
/* read edges properties */
att = agnxtattr(cg,AGEDGE,NULL);
while(att != NULL)
{
/* the only way to iterate over all edges is to iterate
* over the vertices */
for(v = agfstnode(cg); v; v = agnxtnode(cg,v))
{
from = find_id(AGID(v),vertices,vsize);
for(e = agfstout(cg,v); e; e = agnxtout(cg,e))
{
to = find_id(AGID(aghead(e)),vertices,vsize);
igraph_get_eid(g,&eid,from,to,1,0);
SETEAS(g,att->name,eid,agxget(e,att));
}
}
att = agnxtattr(cg,AGEDGE,att);
}
goto cleanup;
error:
igraph_destroy(g);
cleanup:
igraph_vector_destroy(&vertices);
error_de:
igraph_vector_destroy(&edges);
error_d:
agclose(cg);
return err;
}
/* Fan-in/ Fan-out method
*/
igraph_t *ggen_generate_fifo(gsl_rng *r, unsigned long n, unsigned long od, unsigned long id)
{
igraph_t *g = NULL;
igraph_vector_t available_od;
igraph_vector_t out_degrees;
igraph_vector_t vertices;
igraph_vector_t choice;
igraph_vector_t edges;
unsigned long max;
unsigned long i,j,k;
unsigned long vcount = 1;
int err;
ggen_error_start_stack();
if(r == NULL)
GGEN_SET_ERRNO(GGEN_EINVAL);
if(id == 0 || od == 0 || od > n || id > n)
GGEN_SET_ERRNO(GGEN_EINVAL);
g = malloc(sizeof(igraph_t));
GGEN_CHECK_ALLOC(g);
GGEN_FINALLY3(free,g,1);
GGEN_CHECK_IGRAPH(igraph_empty(g,1,1));
GGEN_FINALLY3(igraph_destroy,g,1);
GGEN_CHECK_IGRAPH(igraph_vector_init(&available_od,n));
GGEN_FINALLY(igraph_vector_destroy,&available_od);
GGEN_CHECK_IGRAPH(igraph_vector_init(&out_degrees,n));
GGEN_FINALLY(igraph_vector_destroy,&out_degrees);
GGEN_CHECK_IGRAPH(igraph_vector_init(&vertices,n));
GGEN_FINALLY(igraph_vector_destroy,&vertices);
GGEN_CHECK_IGRAPH(igraph_vector_init(&choice,n));
GGEN_FINALLY(igraph_vector_destroy,&choice);
GGEN_CHECK_IGRAPH(igraph_vector_init(&edges,n*2));
GGEN_FINALLY(igraph_vector_destroy,&edges);
while(vcount < n)
{
// never trigger errors as it doesn't allocate or free memory
igraph_vector_resize(&available_od,vcount);
igraph_vector_resize(&out_degrees,vcount);
igraph_vector_resize(&vertices,vcount);
// compute the available out degree of each vertex
GGEN_CHECK_IGRAPH(igraph_degree(g,&out_degrees,igraph_vss_all(),IGRAPH_OUT,0));
// fill available with od and substract out_degrees
igraph_vector_fill(&available_od,od);
GGEN_CHECK_IGRAPH(igraph_vector_sub(&available_od,&out_degrees));
if(gsl_ran_bernoulli(r,0.5)) //Fan-out Step
{
// find max
max = igraph_vector_max(&available_od);
// register all vertices having max as outdegree
j = 0;
for (i = 0; i < vcount; i++)
if(VECTOR(available_od)[i] == max)
VECTOR(vertices)[j++] = i;
// choose randomly a vertex among availables
GGEN_CHECK_GSL_DO(i = gsl_rng_uniform_int(r,j));
// how many children ?
GGEN_CHECK_GSL_DO(j = gsl_rng_uniform_int(r,max));
j = j+1;
// create all new nodes and add edges
GGEN_CHECK_IGRAPH(igraph_add_vertices(g,j,NULL));
// cannot fail
igraph_vector_resize(&edges,j*2);
for(k = 0; k < j; k++)
{
VECTOR(edges)[2*k] = i;
VECTOR(edges)[2*k+1] = vcount + k;
}
vcount+=k;
}
else //Fan-In Step
{
// register all vertices having an available outdegree
j = 0;
for (i = 0; i < vcount; i++)
if(VECTOR(available_od)[i] > 0)
VECTOR(vertices)[j++] = i;
// we can add at most id vertices
max =( j > id)? id: j;
// how many edges to add
GGEN_CHECK_GSL_DO(k = gsl_rng_uniform_int(r,max));
k = k+1;
// choose that many nodes and add edges from them to the new node
// cannot fail either
igraph_vector_resize(&choice,k);
gsl_ran_choose(r,VECTOR(choice),k,
VECTOR(vertices),j,sizeof(VECTOR(vertices)[0]));
// add a vertex to the graph
GGEN_CHECK_IGRAPH(igraph_add_vertices(g,1,NULL));
igraph_vector_resize(&edges,k*2);
// be carefull, vcount is the last ID of vertices not vcount +1
for(i = 0; i < k; i++)
{
VECTOR(edges)[2*i] = VECTOR(choice)[i];
VECTOR(edges)[2*i+1] = vcount;
}
vcount++;
}
// in all cases, edges should be added
GGEN_CHECK_IGRAPH(igraph_add_edges(g,&edges,NULL));
}
ggen_error_clean(1);
return g;
ggen_error_label:
return NULL;
}
void igraph_i_graphml_sax_handler_end_document(void *state0) {
struct igraph_i_graphml_parser_state *state=
(struct igraph_i_graphml_parser_state*)state0;
long i, l;
int r;
igraph_i_attribute_record_t idrec, eidrec;
const char *idstr="id";
igraph_bool_t already_has_vertex_id=0, already_has_edge_id=0;
if (!state->successful) return;
if (state->index<0) {
igraph_vector_ptr_t vattr, eattr, gattr;
long int esize=igraph_vector_ptr_size(&state->e_attrs);
const void **tmp;
r=igraph_vector_ptr_init(&vattr,
igraph_vector_ptr_size(&state->v_attrs)+1);
if (r) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, r);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &vattr);
if (igraph_strvector_size(&state->edgeids) != 0) {
esize++;
}
r=igraph_vector_ptr_init(&eattr, esize);
if (r) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, r);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &eattr);
r=igraph_vector_ptr_init(&gattr, igraph_vector_ptr_size(&state->g_attrs));
if (r) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, r);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &gattr);
for (i=0; i<igraph_vector_ptr_size(&state->v_attrs); i++) {
igraph_i_graphml_attribute_record_t *graphmlrec=
VECTOR(state->v_attrs)[i];
igraph_i_attribute_record_t *rec=&graphmlrec->record;
/* Check that the name of the vertex attribute is not 'id'.
If it is then we cannot the complimentary 'id' attribute. */
if (! strcmp(rec->name, idstr)) {
already_has_vertex_id=1;
}
if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
igraph_vector_t *vec=(igraph_vector_t*)rec->value;
long int origsize=igraph_vector_size(vec);
long int nodes=igraph_trie_size(&state->node_trie);
igraph_vector_resize(vec, nodes);
for (l=origsize; l<nodes; l++) {
VECTOR(*vec)[l]=IGRAPH_NAN;
}
} else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
igraph_strvector_t *strvec=(igraph_strvector_t*)rec->value;
long int origsize=igraph_strvector_size(strvec);
long int nodes=igraph_trie_size(&state->node_trie);
igraph_strvector_resize(strvec, nodes);
for (l=origsize; l<nodes; l++) {
igraph_strvector_set(strvec, l, "");
}
}
VECTOR(vattr)[i]=rec;
}
if (!already_has_vertex_id) {
idrec.name=idstr;
idrec.type=IGRAPH_ATTRIBUTE_STRING;
tmp=&idrec.value;
igraph_trie_getkeys(&state->node_trie, (const igraph_strvector_t **)tmp);
VECTOR(vattr)[i]=&idrec;
} else {
igraph_vector_ptr_pop_back(&vattr);
IGRAPH_WARNING("Could not add vertex ids, "
"there is already an 'id' vertex attribute");
}
for (i=0; i<igraph_vector_ptr_size(&state->e_attrs); i++) {
igraph_i_graphml_attribute_record_t *graphmlrec=
VECTOR(state->e_attrs)[i];
igraph_i_attribute_record_t *rec=&graphmlrec->record;
if (! strcmp(rec->name, idstr)) {
already_has_edge_id=1;
}
if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
igraph_vector_t *vec=(igraph_vector_t*)rec->value;
long int origsize=igraph_vector_size(vec);
long int edges=igraph_vector_size(&state->edgelist)/2;
igraph_vector_resize(vec, edges);
for (l=origsize; l<edges; l++) {
VECTOR(*vec)[l]=IGRAPH_NAN;
}
} else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
igraph_strvector_t *strvec=(igraph_strvector_t*)rec->value;
long int origsize=igraph_strvector_size(strvec);
long int edges=igraph_vector_size(&state->edgelist)/2;
igraph_strvector_resize(strvec, edges);
for (l=origsize; l<edges; l++) {
igraph_strvector_set(strvec, l, "");
}
}
VECTOR(eattr)[i]=rec;
}
if (igraph_strvector_size(&state->edgeids) != 0) {
if (!already_has_edge_id) {
long int origsize=igraph_strvector_size(&state->edgeids);
eidrec.name=idstr;
eidrec.type=IGRAPH_ATTRIBUTE_STRING;
igraph_strvector_resize(&state->edgeids,
igraph_vector_size(&state->edgelist)/2);
for (; origsize < igraph_strvector_size(&state->edgeids); origsize++) {
igraph_strvector_set(&state->edgeids, origsize, "");
}
eidrec.value=&state->edgeids;
VECTOR(eattr)[(long int)igraph_vector_ptr_size(&eattr)-1]=&eidrec;
} else {
igraph_vector_ptr_pop_back(&eattr);
IGRAPH_WARNING("Could not add edge ids, "
"there is already an 'id' edge attribute");
}
}
for (i=0; i<igraph_vector_ptr_size(&state->g_attrs); i++) {
igraph_i_graphml_attribute_record_t *graphmlrec=
VECTOR(state->g_attrs)[i];
igraph_i_attribute_record_t *rec=&graphmlrec->record;
if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
igraph_vector_t *vec=(igraph_vector_t*)rec->value;
long int origsize=igraph_vector_size(vec);
igraph_vector_resize(vec, 1);
for (l=origsize; l<1; l++) {
VECTOR(*vec)[l]=IGRAPH_NAN;
}
} else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
igraph_strvector_t *strvec=(igraph_strvector_t*)rec->value;
long int origsize=igraph_strvector_size(strvec);
igraph_strvector_resize(strvec, 1);
for (l=origsize; l<1; l++) {
igraph_strvector_set(strvec, l, "");
}
}
VECTOR(gattr)[i]=rec;
}
igraph_empty_attrs(state->g, 0, state->edges_directed, &gattr);
igraph_add_vertices(state->g, igraph_trie_size(&state->node_trie),
&vattr);
igraph_add_edges(state->g, &state->edgelist, &eattr);
igraph_vector_ptr_destroy(&vattr);
igraph_vector_ptr_destroy(&eattr);
igraph_vector_ptr_destroy(&gattr);
IGRAPH_FINALLY_CLEAN(3);
}
igraph_i_graphml_destroy_state(state);
}
VALUE cIGraph_initialize(int argc, VALUE *argv, VALUE self){
igraph_t *graph;
igraph_vector_t edge_v;
VALUE vertex;
VALUE directed;
VALUE edges;
VALUE attrs;
VALUE v_ary;
int vertex_n = 0;
int current_vertex_id;
int i;
igraph_vector_ptr_t vertex_attr;
igraph_vector_ptr_t edge_attr;
igraph_i_attribute_record_t v_attr_rec;
v_attr_rec.name = "__RUBY__";
v_attr_rec.type = IGRAPH_ATTRIBUTE_PY_OBJECT;
v_attr_rec.value = (void*)rb_ary_new();
igraph_i_attribute_record_t e_attr_rec;
e_attr_rec.name = "__RUBY__";
e_attr_rec.type = IGRAPH_ATTRIBUTE_PY_OBJECT;
e_attr_rec.value = (void*)rb_ary_new();
rb_scan_args(argc,argv,"12", &edges, &directed, &attrs);
//Initialize edge vector
IGRAPH_FINALLY(igraph_vector_destroy,&edge_v);
IGRAPH_FINALLY(igraph_vector_ptr_destroy,&vertex_attr);
IGRAPH_FINALLY(igraph_vector_ptr_destroy,&edge_attr);
IGRAPH_CHECK(igraph_vector_init_int(&edge_v,0));
IGRAPH_CHECK(igraph_vector_ptr_init(&vertex_attr,0));
IGRAPH_CHECK(igraph_vector_ptr_init(&edge_attr,0));
Data_Get_Struct(self, igraph_t, graph);
v_ary = rb_ary_new();
if(!directed)
IGRAPH_CHECK(igraph_to_undirected(graph,IGRAPH_TO_UNDIRECTED_COLLAPSE));
//Loop through objects in edge Array
for (i=0; i<RARRAY_LEN(edges); i++) {
vertex = RARRAY_PTR(edges)[i];
if(rb_ary_includes(v_ary,vertex)){
//If @vertices includes this vertex then look up the vertex number
current_vertex_id = NUM2INT(rb_funcall(v_ary,rb_intern("index"),1,vertex));
} else {
//Otherwise add to the list of vertices
rb_ary_push(v_ary,vertex);
current_vertex_id = vertex_n;
vertex_n++;
//Add object to list of vertex attributes
rb_ary_push((VALUE)v_attr_rec.value,vertex);
}
IGRAPH_CHECK(igraph_vector_push_back(&edge_v,current_vertex_id));
if (i % 2){
if (attrs != Qnil){
rb_ary_push((VALUE)e_attr_rec.value,RARRAY_PTR(attrs)[i/2]);
} else {
rb_ary_push((VALUE)e_attr_rec.value,Qnil);
}
}
}
IGRAPH_CHECK(igraph_vector_ptr_push_back(&vertex_attr, &v_attr_rec));
IGRAPH_CHECK(igraph_vector_ptr_push_back(&edge_attr, &e_attr_rec));
if(igraph_vector_size(&edge_v) > 0){
IGRAPH_CHECK(igraph_add_vertices(graph,vertex_n,&vertex_attr));
IGRAPH_CHECK(igraph_add_edges(graph,&edge_v,&edge_attr));
}
igraph_vector_destroy(&edge_v);
igraph_vector_ptr_destroy(&vertex_attr);
igraph_vector_ptr_destroy(&edge_attr);
IGRAPH_FINALLY_CLEAN(3);
return self;
}
void LayoutBuilder::produce(AbstractPetriNetBuilder *builder){
if(!attrTableAttached){
igraph_i_set_attribute_table(&igraph_cattribute_table);
attrTableAttached = true;
}
size_t V = places.size() + transitions.size();
size_t E = inArcs.size() + outArcs.size();
igraph_t graph;
// Create a directed graph
igraph_empty(&graph, V, true);
// Create vector with all edges
igraph_vector_t edges;
igraph_vector_init(&edges, E * 2);
// Add edges to vector
int i = 0;
for(ArcIter it = inArcs.begin(); it != inArcs.end(); it++){
VECTOR(edges)[i++] = numberFromName(it->start);
VECTOR(edges)[i++] = numberFromName(it->end);
}
for(ArcIter it = outArcs.begin(); it != outArcs.end(); it++){
VECTOR(edges)[i++] = numberFromName(it->start);
VECTOR(edges)[i++] = numberFromName(it->end);
}
// Add the edges to graph
igraph_add_edges(&graph, &edges, 0);
// Delete the vector with edges
igraph_vector_destroy(&edges);
// Arrays to store result in
double posx[V];
double posy[V];
// Provide current positions, if they're used at all
if(startFromCurrentPositions){
int i = 0;
for(PlaceIter it = places.begin(); it != places.end(); it++){
posx[i] = it->x;
posy[i] = it->y;
igraph_cattribute_VAN_set(&graph, "id", i, i);
i++;
}
for(TransitionIter it = transitions.begin(); it != transitions.end(); it++){
posx[i] = it->x;
posy[i] = it->y;
igraph_cattribute_VAN_set(&graph, "id", i, i);
i++;
}
}
// Decompose the graph, and layout subgraphs induvidually
igraph_vector_ptr_t subgraphs;
igraph_vector_ptr_init(&subgraphs, 0);
igraph_decompose(&graph, &subgraphs, IGRAPH_WEAK, -1, 0);
// Offset for places subgraphs
double offsetx = 0;
double offsety = 0;
// Layout, translate and extract results for each subgraph
for(int i = 0; i < igraph_vector_ptr_size(&subgraphs); i++){
//Get the subgraph
igraph_t* subgraph = (igraph_t*)VECTOR(subgraphs)[i];
// Allocate result matrix
igraph_matrix_t sublayout;
igraph_matrix_init(&sublayout, 0, 0);
// Vertex selector and iterator
igraph_vs_t vs;
igraph_vit_t vit;
// Select all and create iterator
igraph_vs_all(&vs);
igraph_vit_create(subgraph, vs, &vit);
// Initialize sublayout, using original positions
if(startFromCurrentPositions){
// Count vertices
int vertices = 0;
// Iterator over vertices to count them, hacked but it works
while(!IGRAPH_VIT_END(vit)){
vertices++;
IGRAPH_VIT_NEXT(vit);
}
//Reset vertex iterator
IGRAPH_VIT_RESET(vit);
// Resize sublayout
igraph_matrix_resize(&sublayout, vertices, 2);
// Iterator over vertices
while(!IGRAPH_VIT_END(vit)){
int subindex = (int)IGRAPH_VIT_GET(vit);
int index = (int)igraph_cattribute_VAN(subgraph, "id", subindex);
MATRIX(sublayout, subindex, 0) = posx[index];
MATRIX(sublayout, subindex, 1) = posy[index];
IGRAPH_VIT_NEXT(vit);
}
//Reset vertex iterator
IGRAPH_VIT_RESET(vit);
}
igraph_layout_kamada_kawai(subgraph, &sublayout, 1000, ((double)V)/4.0, 10, 0.99, V*V, startFromCurrentPositions);
// Other layout algorithms with reasonable parameters
//igraph_layout_kamada_kawai(subgraph, &sublayout, 1000, ((double)V)/4.0, 10, 0.99, V*V, startFromCurrentPositions);
//igraph_layout_grid_fruchterman_reingold(subgraph, &sublayout, 500, V, V*V, 1.5, V*V*V, V*V/4, startFromCurrentPositions);
//igraph_layout_fruchterman_reingold(subgraph, &sublayout, 500, V, V*V, 1.5, V*V*V, startFromCurrentPositions, NULL);
//igraph_layout_lgl(subgraph, &sublayout, 150, V, V*V, 1.5, V*V*V, sqrt(V), -1);
//Find min and max values:
double minx = DBL_MAX,
miny = DBL_MAX,
maxx = -DBL_MAX,
maxy = -DBL_MAX;
//Iterator over all vertices
while(!IGRAPH_VIT_END(vit)){
int subindex = (int)IGRAPH_VIT_GET(vit);
double x = MATRIX(sublayout, subindex, 0) * factor;
double y = MATRIX(sublayout, subindex, 1) * factor;
minx = minx < x ? minx : x;
miny = miny < y ? miny : y;
maxx = maxx > x ? maxx : x;
maxy = maxy > y ? maxy : y;
IGRAPH_VIT_NEXT(vit);
}
//Reset vertex iterator
IGRAPH_VIT_RESET(vit);
// Compute translation
double tx = margin - minx;
double ty = margin - miny;
// Decide whether to put it below or left of current content
if(maxx - minx + offsetx < maxy - miny + offsety){
tx += offsetx;
offsetx += maxx - minx + margin;
if(offsety < maxy - miny + margin)
offsety = maxy - miny + margin;
}else{
ty += offsety;
offsety += maxy - miny + margin;
if(offsetx < maxx - minx + margin)
offsetx = maxx - minx + margin;
}
// Translate and extract results
while(!IGRAPH_VIT_END(vit)){
int subindex = (int)IGRAPH_VIT_GET(vit);
int index = (int)igraph_cattribute_VAN(subgraph, "id", subindex);
double x = MATRIX(sublayout, subindex, 0) * factor;
double y = MATRIX(sublayout, subindex, 1) * factor;
posx[index] = x + tx;
posy[index] = y + ty;
IGRAPH_VIT_NEXT(vit);
}
// Destroy iterator and selector
igraph_vit_destroy(&vit);
igraph_vs_destroy(&vs);
// Destroy the sublayout
igraph_matrix_destroy(&sublayout);
// Destroy subgraph
igraph_destroy(subgraph);
free(VECTOR(subgraphs)[i]);
}
// Remove the attributes
igraph_cattribute_remove_v(&graph, "id");
// Destroy the graph
igraph_destroy(&graph);
// Insert results
i = 0;
for(PlaceIter it = places.begin(); it != places.end(); it++){
it->x = posx[i];
it->y = posy[i];
i++;
}
for(TransitionIter it = transitions.begin(); it != transitions.end(); it++){
it->x = posx[i];
it->y = posy[i];
i++;
}
// Produce variables
for(VarIter it = vars.begin(); it != vars.end(); it++)
builder->addVariable(it->name, it->initialValue, it->range);
for(BoolVarIter it = boolVars.begin(); it != boolVars.end(); it++)
builder->addBoolVariable(it->name, it->initialValue);
for(PlaceIter it = places.begin(); it != places.end(); it++)
builder->addPlace(it->name, it->tokens, it->x, it->y);
for(TransitionIter it = transitions.begin(); it != transitions.end(); it++)
builder->addTransition(it->name, it->conditions, it->assignments, it->x, it->y);
for(ArcIter it = inArcs.begin(); it != inArcs.end(); it++)
builder->addInputArc(it->start, it->end, it->weight);
for(ArcIter it = outArcs.begin(); it != outArcs.end(); it++)
builder->addInputArc(it->start, it->end, it->weight);
//Reset builder state (just in case some idoit decides to reuse it!
vars.clear();
boolVars.clear();
places.clear();
transitions.clear();
inArcs.clear();
outArcs.clear();
}
int ggen_transform_add(igraph_t *g, enum ggen_transform_t t)
{
igraph_vector_t vertices;
igraph_vector_t degrees;
igraph_vector_t edges;
unsigned int i,vcount,ssize;
int err;
if(g == NULL)
return 1;
vcount = igraph_vcount(g);
err = igraph_vector_init(&vertices,vcount);
if(err) return 1;
err = igraph_vector_init(°rees,vcount);
if(err) goto error_id;
/* find degree of each vertex, in if new source is wanted. */
err = igraph_degree(g,°rees,igraph_vss_all(),
(t==GGEN_TRANSFORM_SOURCE)?IGRAPH_IN:IGRAPH_OUT,0);
if(err) goto error;
/* only sources or sinks are of interest */
ssize = 0;
for(i = 0; i < vcount; i++)
if(VECTOR(degrees)[i] == 0)
VECTOR(vertices)[ssize++] = i;
/* we have something to do */
if(ssize > 0)
{
err = igraph_add_vertices(g,1,NULL);
if(err) goto error;
err = igraph_vector_init(&edges,ssize*2);
if(err) goto error;
for(i = 0; i < ssize; i++)
{
if(t == GGEN_TRANSFORM_SOURCE)
{
VECTOR(edges)[2*i] = vcount;
VECTOR(edges)[2*i+1] = VECTOR(vertices)[i];
}
else
{
VECTOR(edges)[2*i] = VECTOR(vertices)[i];
VECTOR(edges)[2*i+1] = vcount;
}
}
err = igraph_add_edges(g,&edges,NULL);
igraph_vector_destroy(&edges);
if(err) goto error;
}
error:
igraph_vector_destroy(°rees);
error_id:
igraph_vector_destroy(&vertices);
return err;
}
