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 g1, g2;
igraph_vector_t v1, v2;
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(&g1, &v1, 0, 0);
igraph_copy(&g2, &g1);
igraph_vector_init(&v2, 0);
igraph_get_edgelist(&g2, &v2, 0);
if (!igraph_vector_is_equal(&v1, &v2)) {
return 1;
}
igraph_vector_destroy(&v1);
igraph_vector_destroy(&v2);
igraph_destroy(&g1);
igraph_destroy(&g2);
return 0;
}
void print_graph(igraph_t* graph){
//printf("creating vector\n");
igraph_vector_t v;
//printf("getting edgelist\n");
igraph_get_edgelist(graph, &v, 0);
//printf("printing vector\n");
printf("^{ \"type\":\"graph\", \"name\" : \"test Graph\", \"obj\":[");
print_vector(&v, stdout);
printf("]}\n");
}
void print(igraph_t *g) {
igraph_vector_t el;
long int i, j, n;
char ch = igraph_is_directed(g) ? '>' : '-';
igraph_vector_init(&el, 0);
igraph_get_edgelist(g, &el, 0);
n = igraph_ecount(g);
for (i=0, j=0; i<n; i++, j+=2) {
printf("%ld --%c %ld: %ld\n",
(long)VECTOR(el)[j], ch, (long)VECTOR(el)[j+1], (long)EAN(g, "weight", i));
}
printf("\n");
igraph_vector_destroy(&el);
}
int* readGrafo(){
int *grafo;
igraph_matrix_t gMatrix;
igraph_t g;
igraph_i_set_attribute_table(&igraph_cattribute_table);
FILE *ifile;
ifile=fopen("/home/john/git/primAlgorithm/celegansneural.gml"/*"/home/john/git/primAlgorithm/grafo.gml"*/, "r");
if (ifile==0) {
printf("Problema abriendo archivo de grafo\n");
return NULL;
}
igraph_read_graph_gml(&g, ifile);
fclose(ifile);
numNodos = igraph_vcount(&g);
grafo = malloc(numNodos*numNodos*sizeof(int));
igraph_matrix_init(&gMatrix,numNodos,numNodos);
igraph_get_adjacency(&g,&gMatrix,IGRAPH_GET_ADJACENCY_BOTH,1);
igraph_vector_t el;
int ii, jj, n;
igraph_vector_init(&el, 0);
igraph_get_edgelist(&g, &el, 0);
n = igraph_ecount(&g);
memset(grafo,INT_MAX2,numNodos*numNodos*sizeof(int));
for (ii=0, jj=0; ii<n; ii++, jj+=2) {
grafo[((long)VECTOR(el)[jj])+numNodos*((long)VECTOR(el)[jj+1])] = (int)EAN(&g, "weight", ii);
grafo[((long)VECTOR(el)[jj+1])+numNodos*((long)VECTOR(el)[jj])] = (int)EAN(&g, "weight", ii);
}
printf("\nNumero de nodos %d",numNodos);
igraph_vector_destroy(&el);
igraph_destroy(&g);
return grafo;
}
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;
}
void Graph::getEdgelist(Vector* result, bool bycol) const {
assert(m_pGraph);
IGRAPH_TRY(igraph_get_edgelist(m_pGraph, result->c_vector(), bycol));
}
int igraph_i_read_network(const igraph_t *graph,
const igraph_vector_t *weights,
network *net, float limit,
igraph_bool_t use_weights,
unsigned int states) {
double av_k=0.0, sum_weight=0.0, min_weight=1e60, max_weight=-1e60;
unsigned long min_k=999999999, max_k=0;
long max_index=0;
char name[255];
NNode *node1,*node2;
DLList_Iter<NNode*> iter;
igraph_vector_t edgelist;
long int no_of_edges=(long int)igraph_ecount(graph);
long int ii;
char *empty=new char[1];
empty[0]='\0';
IGRAPH_VECTOR_INIT_FINALLY(&edgelist, no_of_edges*2);
IGRAPH_CHECK(igraph_get_edgelist(graph, &edgelist, 0 /* rowwise */));
for (ii=0; ii<no_of_edges; ii++) {
long int i1=(long int)VECTOR(edgelist)[2*ii]+1;
long int i2=(long int)VECTOR(edgelist)[2*ii+1]+1;
igraph_real_t Links;
if (use_weights) {
Links=VECTOR(*weights)[ii];
} else {
Links=1.0;
}
// From the original source
if (max_index<i1) {
for (int i=max_index; i<i1; i++)
net->node_list->Push(new NNode(i,0,net->link_list, empty,states));
max_index=i1;
}
if (max_index<i2) {
for (int i=max_index; i<i2; i++)
net->node_list->Push(new NNode(i,0,net->link_list, empty,states));
max_index=i2;
}
node1=net->node_list->Get(i1-1);
sprintf(name,"%li",i1);
node1->Set_Name(name);
node2=net->node_list->Get(i2-1);
sprintf(name,"%li",i2);
node2->Set_Name(name);
node1->Connect_To(node2,Links);
if (Links<min_weight) min_weight=Links;
if (Links>max_weight) max_weight=Links;
sum_weight+=Links;
}
IGRAPH_FINALLY_CLEAN(1);
igraph_vector_destroy(&edgelist);
node1=iter.First(net->node_list);
while (!iter.End())
{
if (node1->Get_Degree()>max_k) max_k=node1->Get_Degree();
if (node1->Get_Degree()<min_k) min_k=node1->Get_Degree();
av_k+=node1->Get_Degree();
node1=iter.Next();
}
net->av_k=av_k/double(net->node_list->Size());
net->sum_weights=sum_weight;
net->av_weight=sum_weight/double(net->link_list->Size());
net->min_k=min_k;
net->max_k=max_k;
net->min_weight=min_weight;
net->max_weight=max_weight;
net->sum_bids=0;
net->min_bids=0;
net->max_bids=0;
delete [] empty;
return 0;
}
int igraph_union_many(igraph_t *res, const igraph_vector_ptr_t *graphs,
igraph_vector_ptr_t *edgemaps) {
long int no_of_graphs=igraph_vector_ptr_size(graphs);
long int no_of_nodes=0;
igraph_bool_t directed=1;
igraph_vector_t edges;
igraph_vector_ptr_t edge_vects, order_vects;
igraph_vector_long_t no_edges;
long int i, j, tailfrom= no_of_graphs > 0 ? 0 : -1, tailto=-1;
long int idx=0;
/* Check directedness */
if (no_of_graphs != 0) {
directed=igraph_is_directed(VECTOR(*graphs)[0]);
no_of_nodes=igraph_vcount(VECTOR(*graphs)[0]);
}
for (i=1; i<no_of_graphs; i++) {
if (directed != igraph_is_directed(VECTOR(*graphs)[i])) {
IGRAPH_ERROR("Cannot union directed and undirected graphs",
IGRAPH_EINVAL);
}
}
if (edgemaps) {
IGRAPH_CHECK(igraph_vector_ptr_resize(edgemaps, no_of_graphs));
igraph_vector_ptr_null(edgemaps);
IGRAPH_FINALLY(igraph_i_union_many_free3, edgemaps);
}
IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
IGRAPH_CHECK(igraph_vector_long_init(&no_edges, no_of_graphs));
IGRAPH_FINALLY(igraph_vector_long_destroy, &no_edges);
/* Calculate number of nodes, query number of edges */
for (i=0; i<no_of_graphs; i++) {
long int n=igraph_vcount(VECTOR(*graphs)[i]);
if (n > no_of_nodes) {
no_of_nodes=n;
}
VECTOR(no_edges)[i] = igraph_ecount(VECTOR(*graphs)[i]);
}
if (edgemaps) {
for (i=0; i<no_of_graphs; i++) {
VECTOR(*edgemaps)[i]=igraph_Calloc(1, igraph_vector_t);
if (!VECTOR(*edgemaps)[i]) {
IGRAPH_ERROR("Cannot union graphs", IGRAPH_ENOMEM);
}
IGRAPH_CHECK(igraph_vector_init(VECTOR(*edgemaps)[i],
VECTOR(no_edges)[i]));
}
}
/* Allocate memory for the edge lists and their index vectors */
if (no_of_graphs != 0) {
IGRAPH_CHECK(igraph_vector_ptr_init(&edge_vects, no_of_graphs));
IGRAPH_FINALLY(igraph_i_union_many_free, &edge_vects);
IGRAPH_CHECK(igraph_vector_ptr_init(&order_vects, no_of_graphs));
IGRAPH_FINALLY(igraph_i_union_many_free2, &order_vects);
}
for (i=0; i<no_of_graphs; i++) {
VECTOR(edge_vects)[i]=igraph_Calloc(1, igraph_vector_t);
VECTOR(order_vects)[i]=igraph_Calloc(1, igraph_vector_long_t);
if (! VECTOR(edge_vects)[i] || ! VECTOR(order_vects)[i]) {
IGRAPH_ERROR("Cannot union graphs", IGRAPH_ENOMEM);
}
IGRAPH_CHECK(igraph_vector_init(VECTOR(edge_vects)[i],
2 * VECTOR(no_edges)[i]));
IGRAPH_CHECK(igraph_vector_long_init(VECTOR(order_vects)[i],
VECTOR(no_edges)[i]));
}
/* Query and sort the edge lists */
for (i=0; i<no_of_graphs; i++) {
long int k, j, n=VECTOR(no_edges)[i];
igraph_vector_t *edges=VECTOR(edge_vects)[i];
igraph_vector_long_t *order=VECTOR(order_vects)[i];
IGRAPH_CHECK(igraph_get_edgelist(VECTOR(*graphs)[i], edges, /*bycol=*/0));
if (!directed) {
for (k=0, j=0; k<n; k++, j+=2) {
if (VECTOR(*edges)[j] > VECTOR(*edges)[j+1]) {
long int tmp=VECTOR(*edges)[j];
VECTOR(*edges)[j]=VECTOR(*edges)[j+1];
VECTOR(*edges)[j+1]=tmp;
}
}
}
for (k=0; k<n; k++) { VECTOR(*order)[k]=k; }
igraph_qsort_r(VECTOR(*order), n, sizeof(VECTOR(*order)[0]), edges,
igraph_i_order_edgelist_cmp);
}
while (tailfrom >= 0) {
/* Get the largest tail element */
tailfrom = tailto = -1;
for (j=0; j<no_of_graphs; j++) {
if (!igraph_vector_long_empty(VECTOR(order_vects)[j])) {
long int edge=igraph_vector_long_tail(VECTOR(order_vects)[j]);
igraph_vector_t *ev=VECTOR(edge_vects)[j];
long int from=VECTOR(*ev)[2*edge];
long int to=VECTOR(*ev)[2*edge+1];
if (from > tailfrom || (from == tailfrom && to > tailto)) {
tailfrom = from; tailto = to;
}
}
}
if (tailfrom < 0) { continue; }
/* add the edge */
IGRAPH_CHECK(igraph_vector_push_back(&edges, tailfrom));
IGRAPH_CHECK(igraph_vector_push_back(&edges, tailto));
/* update edge lists, we just modify the 'order' vectors */
for (j=0; j<no_of_graphs; j++) {
if (!igraph_vector_long_empty(VECTOR(order_vects)[j])) {
long int edge=igraph_vector_long_tail(VECTOR(order_vects)[j]);
igraph_vector_t *ev=VECTOR(edge_vects)[j];
long int from=VECTOR(*ev)[2*edge];
long int to=VECTOR(*ev)[2*edge+1];
if (from == tailfrom && to == tailto) {
igraph_vector_long_pop_back(VECTOR(order_vects)[j]);
if (edgemaps) {
igraph_vector_t *map=VECTOR(*edgemaps)[j];
VECTOR(*map)[edge]=idx;
}
}
}
}
idx++;
}
if (no_of_graphs > 0) {
igraph_i_union_many_free2(&order_vects);
igraph_i_union_many_free(&edge_vects);
IGRAPH_FINALLY_CLEAN(2);
}
igraph_vector_long_destroy(&no_edges);
IGRAPH_FINALLY_CLEAN(1);
IGRAPH_CHECK(igraph_create(res, &edges, (igraph_integer_t) no_of_nodes,
directed));
igraph_vector_destroy(&edges);
IGRAPH_FINALLY_CLEAN(1);
if (edgemaps) { IGRAPH_FINALLY_CLEAN(1); }
return 0;
}
int igraph_intersection_many(igraph_t *res,
const igraph_vector_ptr_t *graphs,
igraph_vector_ptr_t *edgemaps) {
long int no_of_graphs=igraph_vector_ptr_size(graphs);
long int no_of_nodes=0;
igraph_bool_t directed=1;
igraph_vector_t edges;
igraph_vector_ptr_t edge_vects, order_vects;
long int i, j, tailfrom = no_of_graphs > 0 ? 0 : -1, tailto=-1;
igraph_vector_long_t no_edges;
igraph_bool_t allne= no_of_graphs == 0 ? 0 : 1, allsame=0;
long int idx=0;
/* Check directedness */
if (no_of_graphs != 0) {
directed=igraph_is_directed(VECTOR(*graphs)[0]);
}
for (i=1; i<no_of_graphs; i++) {
if (directed != igraph_is_directed(VECTOR(*graphs)[i])) {
IGRAPH_ERROR("Cannot intersect directed and undirected graphs",
IGRAPH_EINVAL);
}
}
if (edgemaps) {
IGRAPH_CHECK(igraph_vector_ptr_resize(edgemaps, no_of_graphs));
igraph_vector_ptr_null(edgemaps);
IGRAPH_FINALLY(igraph_i_union_many_free3, edgemaps);
}
IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
IGRAPH_CHECK(igraph_vector_long_init(&no_edges, no_of_graphs));
IGRAPH_FINALLY(igraph_vector_long_destroy, &no_edges);
/* Calculate number of nodes, query number of edges */
for (i=0; i<no_of_graphs; i++) {
long int n=igraph_vcount(VECTOR(*graphs)[i]);
if (n > no_of_nodes) { no_of_nodes=n; }
VECTOR(no_edges)[i] = igraph_ecount(VECTOR(*graphs)[i]);
allne = allne && VECTOR(no_edges)[i] > 0;
}
if (edgemaps) {
for (i=0; i<no_of_graphs; i++) {
VECTOR(*edgemaps)[i]=igraph_Calloc(1, igraph_vector_t);
if (!VECTOR(*edgemaps)[i]) {
IGRAPH_ERROR("Cannot intersect graphs", IGRAPH_ENOMEM);
}
IGRAPH_CHECK(igraph_vector_init(VECTOR(*edgemaps)[i],
VECTOR(no_edges)[i]));
igraph_vector_fill(VECTOR(*edgemaps)[i], -1);
}
}
/* Allocate memory for the edge lists and their index vectors */
if (no_of_graphs != 0) {
IGRAPH_CHECK(igraph_vector_ptr_init(&edge_vects, no_of_graphs));
IGRAPH_FINALLY(igraph_i_union_many_free, &edge_vects);
IGRAPH_CHECK(igraph_vector_ptr_init(&order_vects, no_of_graphs));
IGRAPH_FINALLY(igraph_i_union_many_free2, &order_vects);
}
for (i=0; i<no_of_graphs; i++) {
VECTOR(edge_vects)[i]=igraph_Calloc(1, igraph_vector_t);
VECTOR(order_vects)[i]=igraph_Calloc(1, igraph_vector_long_t);
if (! VECTOR(edge_vects)[i] || ! VECTOR(order_vects)[i]) {
IGRAPH_ERROR("Cannot intersect graphs", IGRAPH_ENOMEM);
}
IGRAPH_CHECK(igraph_vector_init(VECTOR(edge_vects)[i],
2 * VECTOR(no_edges)[i]));
IGRAPH_CHECK(igraph_vector_long_init(VECTOR(order_vects)[i],
VECTOR(no_edges)[i]));
}
/* Query and sort the edge lists */
for (i=0; i<no_of_graphs; i++) {
long int k, j, n=VECTOR(no_edges)[i];
igraph_vector_t *edges=VECTOR(edge_vects)[i];
igraph_vector_long_t *order=VECTOR(order_vects)[i];
IGRAPH_CHECK(igraph_get_edgelist(VECTOR(*graphs)[i], edges, /*bycol=*/0));
if (!directed) {
for (k=0, j=0; k<n; k++, j+=2) {
if (VECTOR(*edges)[j] > VECTOR(*edges)[j+1]) {
long int tmp=VECTOR(*edges)[j];
VECTOR(*edges)[j]=VECTOR(*edges)[j+1];
VECTOR(*edges)[j+1]=tmp;
}
}
}
for (k=0; k<n; k++) { VECTOR(*order)[k]=k; }
igraph_qsort_r(VECTOR(*order), n, sizeof(VECTOR(*order)[0]), edges,
igraph_i_order_edgelist_cmp);
}
/* Do the merge. We work from the end of the edge lists,
because then we don't have to keep track of where we are right
now in the edge and order lists. We find the "largest" edge,
and if it is present in all graphs, then we copy it to the
result. We remove all instances of this edge. */
while (allne) {
/* Look for the smallest tail element */
for (j=0, tailfrom=LONG_MAX, tailto=LONG_MAX; j<no_of_graphs; j++) {
long int edge=igraph_vector_long_tail(VECTOR(order_vects)[j]);
igraph_vector_t *ev=VECTOR(edge_vects)[j];
long int from=VECTOR(*ev)[2*edge];
long int to=VECTOR(*ev)[2*edge+1];
if (from < tailfrom || (from == tailfrom && to < tailto)) {
tailfrom = from; tailto = to;
}
}
/* OK, now remove all elements from the tail(s) that are bigger
than the smallest tail element. */
for (j=0, allsame=1; j<no_of_graphs; j++) {
long int from=-1, to=-1;
while (1) {
long int edge=igraph_vector_long_tail(VECTOR(order_vects)[j]);
igraph_vector_t *ev=VECTOR(edge_vects)[j];
from=VECTOR(*ev)[2*edge];
to=VECTOR(*ev)[2*edge+1];
if (from > tailfrom || (from==tailfrom && to > tailto)) {
igraph_vector_long_pop_back(VECTOR(order_vects)[j]);
if (igraph_vector_long_empty(VECTOR(order_vects)[j])) {
allne=0;
break;
}
} else {
break;
}
}
if (from != tailfrom || to != tailto) { allsame=0; }
}
/* Add the edge, if the smallest tail element was present
in all graphs. */
if (allsame) {
IGRAPH_CHECK(igraph_vector_push_back(&edges, tailfrom));
IGRAPH_CHECK(igraph_vector_push_back(&edges, tailto));
}
/* Drop edges matching the smalles tail elements
from the order vectors, build edge maps */
if (allne) {
for (j=0; j<no_of_graphs; j++) {
long int edge=igraph_vector_long_tail(VECTOR(order_vects)[j]);
igraph_vector_t *ev=VECTOR(edge_vects)[j];
long int from=VECTOR(*ev)[2*edge];
long int to=VECTOR(*ev)[2*edge+1];
if (from == tailfrom && to == tailto) {
igraph_vector_long_pop_back(VECTOR(order_vects)[j]);
if (igraph_vector_long_empty(VECTOR(order_vects)[j])) {
allne=0;
}
if (edgemaps && allsame) {
igraph_vector_t *map=VECTOR(*edgemaps)[j];
VECTOR(*map)[edge]=idx;
}
}
}
if (allsame) { idx++; }
}
} /* while allne */
if (no_of_graphs > 0) {
igraph_i_union_many_free2(&order_vects);
igraph_i_union_many_free(&edge_vects);
IGRAPH_FINALLY_CLEAN(2);
}
igraph_vector_long_destroy(&no_edges);
IGRAPH_FINALLY_CLEAN(1);
IGRAPH_CHECK(igraph_create(res, &edges, (igraph_integer_t) no_of_nodes,
directed));
igraph_vector_destroy(&edges);
IGRAPH_FINALLY_CLEAN(1);
if (edgemaps) { IGRAPH_FINALLY_CLEAN(1); }
return 0;
}
int igraph_i_merge(igraph_t *res, int mode,
const igraph_t *left, const igraph_t *right,
igraph_vector_t *edge_map1, igraph_vector_t *edge_map2) {
long int no_of_nodes_left=igraph_vcount(left);
long int no_of_nodes_right=igraph_vcount(right);
long int no_of_nodes;
long int no_edges_left=igraph_ecount(left);
long int no_edges_right=igraph_ecount(right);
igraph_bool_t directed=igraph_is_directed(left);
igraph_vector_t edges;
igraph_vector_t edges1, edges2;
igraph_vector_long_t order1, order2;
long int i, j, eptr=0;
long int idx1, idx2, edge1=-1, edge2=-1, from1=-1, from2=-1, to1=-1, to2=-1;
igraph_bool_t l;
if (directed != igraph_is_directed(right)) {
IGRAPH_ERROR("Cannot make union or intersection of directed "
"and undirected graph", IGRAPH_EINVAL);
}
IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
IGRAPH_VECTOR_INIT_FINALLY(&edges1, no_edges_left*2);
IGRAPH_VECTOR_INIT_FINALLY(&edges2, no_edges_right*2);
IGRAPH_CHECK(igraph_vector_long_init(&order1, no_edges_left));
IGRAPH_FINALLY(igraph_vector_long_destroy, &order1);
IGRAPH_CHECK(igraph_vector_long_init(&order2, no_edges_right));
IGRAPH_FINALLY(igraph_vector_long_destroy, &order2);
if (edge_map1) {
switch (mode) {
case IGRAPH_MODE_UNION:
IGRAPH_CHECK(igraph_vector_resize(edge_map1, no_edges_left));
break;
case IGRAPH_MODE_INTERSECTION:
igraph_vector_clear(edge_map1);
break;
}
}
if (edge_map2) {
switch (mode) {
case IGRAPH_MODE_UNION:
IGRAPH_CHECK(igraph_vector_resize(edge_map2, no_edges_right));
break;
case IGRAPH_MODE_INTERSECTION:
igraph_vector_clear(edge_map2);
break;
}
}
no_of_nodes=no_of_nodes_left > no_of_nodes_right ?
no_of_nodes_left : no_of_nodes_right;
/* We merge the two edge lists. We need to sort them first.
For undirected graphs, we also need to make sure that
for every edge, that larger (non-smaller) vertex id is in the
second column. */
IGRAPH_CHECK(igraph_get_edgelist(left, &edges1, /*bycol=*/ 0));
IGRAPH_CHECK(igraph_get_edgelist(right, &edges2, /*bycol=*/ 0));
if (!directed) {
for (i=0, j=0; i<no_edges_left; i++, j+=2) {
if (VECTOR(edges1)[j] > VECTOR(edges1)[j+1]) {
long int tmp=VECTOR(edges1)[j];
VECTOR(edges1)[j]=VECTOR(edges1)[j+1];
VECTOR(edges1)[j+1]=tmp;
}
}
for (i=0, j=0; i<no_edges_right; i++, j+=2) {
if (VECTOR(edges2)[j] > VECTOR(edges2)[j+1]) {
long int tmp=VECTOR(edges2)[j];
VECTOR(edges2)[j]=VECTOR(edges2)[j+1];
VECTOR(edges2)[j+1]=tmp;
}
}
}
for (i=0; i<no_edges_left; i++) {
VECTOR(order1)[i]=i;
}
for (i=0; i<no_edges_right; i++) {
VECTOR(order2)[i]=i;
}
igraph_qsort_r(VECTOR(order1), no_edges_left, sizeof(VECTOR(order1)[0]),
&edges1, igraph_i_order_edgelist_cmp);
igraph_qsort_r(VECTOR(order2), no_edges_right, sizeof(VECTOR(order2)[0]),
&edges2, igraph_i_order_edgelist_cmp);
#define INC1() if ( (++idx1) < no_edges_left) { \
edge1 = VECTOR(order1)[idx1]; \
from1 = VECTOR(edges1)[2*edge1]; \
to1 = VECTOR(edges1)[2*edge1+1]; \
}
#define INC2() if ( (++idx2) < no_edges_right) { \
edge2 = VECTOR(order2)[idx2]; \
from2 = VECTOR(edges2)[2*edge2]; \
to2 = VECTOR(edges2)[2*edge2+1]; \
}
idx1 = idx2 = -1;
INC1();
INC2();
#define CONT() switch (mode) { \
case IGRAPH_MODE_UNION: \
l = idx1 < no_edges_left || idx2 < no_edges_right; \
break; \
case IGRAPH_MODE_INTERSECTION: \
l = idx1 < no_edges_left && idx2 < no_edges_right; \
break; \
}
CONT();
while (l) {
if (idx2 >= no_edges_right ||
(idx1 < no_edges_left && from1 < from2) ||
(idx1 < no_edges_left && from1 == from2 && to1 < to2)) {
/* Edge from first graph */
if (mode==IGRAPH_MODE_UNION) {
IGRAPH_CHECK(igraph_vector_push_back(&edges, from1));
IGRAPH_CHECK(igraph_vector_push_back(&edges, to1));
if (edge_map1) { VECTOR(*edge_map1)[edge1]=eptr; }
eptr++;
}
INC1();
} else if (idx1 >= no_edges_left ||
(idx2 < no_edges_right && from2 < from1) ||
(idx2 < no_edges_right && from1 == from2 && to2 < to1)) {
/* Edge from second graph */
if (mode==IGRAPH_MODE_UNION) {
IGRAPH_CHECK(igraph_vector_push_back(&edges, from2));
IGRAPH_CHECK(igraph_vector_push_back(&edges, to2));
if (edge_map2) { VECTOR(*edge_map2)[edge2]=eptr; }
eptr++;
}
INC2();
} else {
/* Edge from both */
IGRAPH_CHECK(igraph_vector_push_back(&edges, from1));
IGRAPH_CHECK(igraph_vector_push_back(&edges, to1));
if (mode==IGRAPH_MODE_UNION) {
if (edge_map1) { VECTOR(*edge_map1)[edge1]=eptr; }
if (edge_map2) { VECTOR(*edge_map2)[edge2]=eptr; }
} else if (mode==IGRAPH_MODE_INTERSECTION) {
if (edge_map1) {
IGRAPH_CHECK(igraph_vector_push_back(edge_map1, edge1));
}
if (edge_map2) {
IGRAPH_CHECK(igraph_vector_push_back(edge_map2, edge2));
}
}
eptr++;
INC1();
INC2();
}
CONT();
}
#undef INC1
#undef INC2
igraph_vector_long_destroy(&order2);
igraph_vector_long_destroy(&order1);
igraph_vector_destroy(&edges2);
igraph_vector_destroy(&edges1);
IGRAPH_FINALLY_CLEAN(4);
IGRAPH_CHECK(igraph_create(res, &edges, no_of_nodes, directed));
igraph_vector_destroy(&edges);
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int igraph_to_directed(igraph_t *graph,
igraph_to_directed_t mode) {
if (mode != IGRAPH_TO_DIRECTED_ARBITRARY &&
mode != IGRAPH_TO_DIRECTED_MUTUAL) {
IGRAPH_ERROR("Cannot directed graph, invalid mode", IGRAPH_EINVAL);
}
if (igraph_is_directed(graph)) {
return 0;
}
if (mode==IGRAPH_TO_DIRECTED_ARBITRARY) {
igraph_t newgraph;
igraph_vector_t edges;
long int no_of_edges=igraph_ecount(graph);
long int no_of_nodes=igraph_vcount(graph);
long int size=no_of_edges*2;
IGRAPH_VECTOR_INIT_FINALLY(&edges, size);
IGRAPH_CHECK(igraph_get_edgelist(graph, &edges, 0));
IGRAPH_CHECK(igraph_create(&newgraph, &edges, no_of_nodes,
IGRAPH_DIRECTED));
IGRAPH_FINALLY(igraph_destroy, &newgraph);
igraph_vector_destroy(&edges);
IGRAPH_I_ATTRIBUTE_DESTROY(&newgraph);
IGRAPH_I_ATTRIBUTE_COPY(&newgraph, graph, 1,1,1);
IGRAPH_FINALLY_CLEAN(2);
igraph_destroy(graph);
*graph=newgraph;
} else if (mode==IGRAPH_TO_DIRECTED_MUTUAL) {
igraph_t newgraph;
igraph_vector_t edges;
igraph_vector_t index;
long int no_of_edges=igraph_ecount(graph);
long int no_of_nodes=igraph_vcount(graph);
long int size=no_of_edges*4;
long int i;
IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
IGRAPH_CHECK(igraph_vector_reserve(&edges, size));
IGRAPH_CHECK(igraph_get_edgelist(graph, &edges, 0));
IGRAPH_CHECK(igraph_vector_resize(&edges, no_of_edges*4));
IGRAPH_VECTOR_INIT_FINALLY(&index, no_of_edges*2);
for (i=0; i<no_of_edges; i++) {
VECTOR(edges)[no_of_edges*2+i*2] =VECTOR(edges)[i*2+1];
VECTOR(edges)[no_of_edges*2+i*2+1]=VECTOR(edges)[i*2];
VECTOR(index)[i] = VECTOR(index)[no_of_edges+i] = i+1;
}
IGRAPH_CHECK(igraph_create(&newgraph, &edges, no_of_nodes,
IGRAPH_DIRECTED));
IGRAPH_FINALLY(igraph_destroy, &newgraph);
IGRAPH_I_ATTRIBUTE_DESTROY(&newgraph);
IGRAPH_I_ATTRIBUTE_COPY(&newgraph, graph, 1,1,1);
IGRAPH_CHECK(igraph_i_attribute_permute_edges(&newgraph, &index));
igraph_vector_destroy(&index);
igraph_vector_destroy(&edges);
igraph_destroy(graph);
IGRAPH_FINALLY_CLEAN(3);
*graph=newgraph;
}
return 0;
}
int main() {
igraph_t g, extd_g;
igraph_matrix_t coords;
igraph_vector_t edgelist, extd_edgelist, extd_to_orig_eids;
igraph_vector_t layers;
igraph_matrix_init(&coords, 0, 0);
igraph_vector_init(&extd_to_orig_eids, 0);
/* Layout on simple graph with predefined layers */
igraph_vector_init_int_end(&layers, -1, 0,1,1,2,3,3,4,4,5, -1);
igraph_vector_init_int_end(&edgelist, -1,
0,1, 0,2, 0,3, 1,2, 2,2, 1,4, 2,5, 4,6, 5,7, 6,8, 7,8,
3,8, 8,1, 8,2, -1);
igraph_create(&g, &edgelist, 0, 1);
igraph_layout_sugiyama(&g, &coords, 0, 0, &layers,
/* hgap = */ 1,
/* vgap = */ 1,
/* maxiter = */ 100,
/* weights = */ 0);
igraph_matrix_print(&coords);
printf("===\n");
/* Same, but this time also return the extended graph */
igraph_layout_sugiyama(&g, &coords, &extd_g, &extd_to_orig_eids, &layers,
/* hgap = */ 1,
/* vgap = */ 1,
/* maxiter = */ 100,
/* weights = */ 0);
igraph_matrix_print(&coords);
printf("===\n");
igraph_vector_init(&extd_edgelist, 0);
igraph_get_edgelist(&extd_g, &extd_edgelist, 0);
igraph_vector_print(&extd_edgelist);
igraph_vector_destroy(&extd_edgelist);
igraph_destroy(&extd_g);
printf("===\n");
igraph_vector_print(&extd_to_orig_eids);
printf("===\n");
igraph_vector_destroy(&layers);
/* Same, but with automatic layering */
igraph_layout_sugiyama(&g, &coords, 0, 0, 0,
/* hgap = */ 1,
/* vgap = */ 1,
/* maxiter = */ 100,
/* weights = */ 0);
igraph_matrix_print(&coords);
printf("===\n");
/* Layering with gaps in it */
igraph_vector_init_int_end(&layers, -1, 0,2,2,4,6,6,12,12,15, -1);
igraph_layout_sugiyama(&g, &coords, 0, 0, &layers,
/* hgap = */ 1,
/* vgap = */ 1,
/* maxiter = */ 100,
/* weights = */ 0);
igraph_matrix_print(&coords);
igraph_vector_destroy(&layers);
printf("===\n");
igraph_vector_destroy(&edgelist);
igraph_matrix_destroy(&coords);
igraph_vector_destroy(&extd_to_orig_eids);
igraph_destroy(&g);
return 0;
}
/**
* Finding maximum bipartite matchings on bipartite graphs using the
* Hungarian algorithm (a.k.a. Kuhn-Munkres algorithm).
*
* The algorithm uses a maximum cardinality matching on a subset of
* tight edges as a starting point. This is achieved by
* \c igraph_i_maximum_bipartite_matching_unweighted on the restricted
* graph.
*
* The algorithm works reliably only if the weights are integers. The
* \c eps parameter should specity a very small number; if the slack on
* an edge falls below \c eps, it will be considered tight. If all your
* weights are integers, you can safely set \c eps to zero.
*/
int igraph_i_maximum_bipartite_matching_weighted(const igraph_t* graph,
const igraph_vector_bool_t* types, igraph_integer_t* matching_size,
igraph_real_t* matching_weight, igraph_vector_long_t* matching,
const igraph_vector_t* weights, igraph_real_t eps) {
long int i, j, k, n, no_of_nodes, no_of_edges;
igraph_integer_t u, v, w, msize;
igraph_t newgraph;
igraph_vector_long_t match; /* will store the matching */
igraph_vector_t slack; /* will store the slack on each edge */
igraph_vector_t parent; /* parent vertices during a BFS */
igraph_vector_t vec1, vec2; /* general temporary vectors */
igraph_vector_t labels; /* will store the labels */
igraph_dqueue_long_t q; /* a FIFO for BST */
igraph_bool_t smaller_set; /* denotes which part of the bipartite graph is smaller */
long int smaller_set_size; /* size of the smaller set */
igraph_real_t dual; /* solution of the dual problem */
igraph_adjlist_t tight_phantom_edges; /* adjacency list to manage tight phantom edges */
igraph_integer_t alternating_path_endpoint;
igraph_vector_t* neis;
igraph_vector_int_t *neis2;
igraph_inclist_t inclist; /* incidence list of the original graph */
/* The Hungarian algorithm is originally for complete bipartite graphs.
* For non-complete bipartite graphs, a phantom edge of weight zero must be
* added between every pair of non-connected vertices. We don't do this
* explicitly of course. See the comments below about how phantom edges
* are taken into account. */
no_of_nodes = igraph_vcount(graph);
no_of_edges = igraph_ecount(graph);
if (eps < 0) {
IGRAPH_WARNING("negative epsilon given, clamping to zero");
eps = 0;
}
/* (1) Initialize data structures */
IGRAPH_CHECK(igraph_vector_long_init(&match, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &match);
IGRAPH_CHECK(igraph_vector_init(&slack, no_of_edges));
IGRAPH_FINALLY(igraph_vector_destroy, &slack);
IGRAPH_VECTOR_INIT_FINALLY(&vec1, 0);
IGRAPH_VECTOR_INIT_FINALLY(&vec2, 0);
IGRAPH_VECTOR_INIT_FINALLY(&labels, no_of_nodes);
IGRAPH_CHECK(igraph_dqueue_long_init(&q, 0));
IGRAPH_FINALLY(igraph_dqueue_long_destroy, &q);
IGRAPH_VECTOR_INIT_FINALLY(&parent, no_of_nodes);
IGRAPH_CHECK(igraph_adjlist_init_empty(&tight_phantom_edges,
(igraph_integer_t) no_of_nodes));
IGRAPH_FINALLY(igraph_adjlist_destroy, &tight_phantom_edges);
IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_inclist_destroy, &inclist);
/* (2) Find which set is the smaller one */
j = 0;
for (i = 0; i < no_of_nodes; i++) {
if (VECTOR(*types)[i] == 0)
j++;
}
smaller_set = (j > no_of_nodes / 2);
smaller_set_size = smaller_set ? (no_of_nodes - j) : j;
/* (3) Calculate the initial labeling and the set of tight edges. Use the
* smaller set only. Here we can assume that there are no phantom edges
* among the tight ones. */
dual = 0;
for (i = 0; i < no_of_nodes; i++) {
igraph_real_t max_weight = 0;
if (VECTOR(*types)[i] != smaller_set) {
VECTOR(labels)[i] = 0;
continue;
}
neis = igraph_inclist_get(&inclist, i);
n = igraph_vector_size(neis);
for (j = 0, k = 0; j < n; j++) {
if (VECTOR(*weights)[(long int)VECTOR(*neis)[j]] > max_weight) {
k = (long int) VECTOR(*neis)[j];
max_weight = VECTOR(*weights)[k];
}
}
VECTOR(labels)[i] = max_weight;
dual += max_weight;
}
igraph_vector_clear(&vec1);
IGRAPH_CHECK(igraph_get_edgelist(graph, &vec2, 0));
#define IS_TIGHT(i) (VECTOR(slack)[i] <= eps)
for (i = 0, j = 0; i < no_of_edges; i++, j+=2) {
u = (igraph_integer_t) VECTOR(vec2)[j];
v = (igraph_integer_t) VECTOR(vec2)[j+1];
VECTOR(slack)[i] = VECTOR(labels)[u] + VECTOR(labels)[v] - VECTOR(*weights)[i];
if (IS_TIGHT(i)) {
IGRAPH_CHECK(igraph_vector_push_back(&vec1, u));
IGRAPH_CHECK(igraph_vector_push_back(&vec1, v));
}
}
igraph_vector_clear(&vec2);
/* (4) Construct a temporary graph on which the initial maximum matching
* will be calculated (only on the subset of tight edges) */
IGRAPH_CHECK(igraph_create(&newgraph, &vec1,
(igraph_integer_t) no_of_nodes, 0));
IGRAPH_FINALLY(igraph_destroy, &newgraph);
IGRAPH_CHECK(igraph_maximum_bipartite_matching(&newgraph, types, &msize, 0, &match, 0, 0));
igraph_destroy(&newgraph);
IGRAPH_FINALLY_CLEAN(1);
/* (5) Main loop until the matching becomes maximal */
while (msize < smaller_set_size) {
igraph_real_t min_slack, min_slack_2;
igraph_integer_t min_slack_u, min_slack_v;
/* (7) Fill the push queue with the unmatched nodes from the smaller set. */
igraph_vector_clear(&vec1);
igraph_vector_clear(&vec2);
igraph_vector_fill(&parent, -1);
for (i = 0; i < no_of_nodes; i++) {
if (UNMATCHED(i) && VECTOR(*types)[i] == smaller_set) {
IGRAPH_CHECK(igraph_dqueue_long_push(&q, i));
VECTOR(parent)[i] = i;
IGRAPH_CHECK(igraph_vector_push_back(&vec1, i));
}
}
#ifdef MATCHING_DEBUG
debug("Matching:");
igraph_vector_long_print(&match);
debug("Unmatched vertices are marked by non-negative numbers:\n");
igraph_vector_print(&parent);
debug("Labeling:");
igraph_vector_print(&labels);
debug("Slacks:");
igraph_vector_print(&slack);
#endif
/* (8) Run the BFS */
alternating_path_endpoint = -1;
while (!igraph_dqueue_long_empty(&q)) {
v = (int) igraph_dqueue_long_pop(&q);
debug("Considering vertex %ld\n", (long int)v);
/* v is always in the smaller set. Find the neighbors of v, which
* are all in the larger set. Find the pairs of these nodes in
* the smaller set and push them to the queue. Mark the traversed
* nodes as seen.
*
* Here we have to be careful as there are two types of incident
* edges on v: real edges and phantom ones. Real edges are
* given by igraph_inclist_get. Phantom edges are not given so we
* (ab)use an adjacency list data structure that lists the
* vertices connected to v by phantom edges only. */
neis = igraph_inclist_get(&inclist, v);
n = igraph_vector_size(neis);
for (i = 0; i < n; i++) {
j = (long int) VECTOR(*neis)[i];
/* We only care about tight edges */
if (!IS_TIGHT(j))
continue;
/* Have we seen the other endpoint already? */
u = IGRAPH_OTHER(graph, j, v);
if (VECTOR(parent)[u] >= 0)
continue;
debug(" Reached vertex %ld via edge %ld\n", (long)u, (long)j);
VECTOR(parent)[u] = v;
IGRAPH_CHECK(igraph_vector_push_back(&vec2, u));
w = (int) VECTOR(match)[u];
if (w == -1) {
/* u is unmatched and it is in the larger set. Therefore, we
* could improve the matching by following the parents back
* from u to the root.
*/
alternating_path_endpoint = u;
break; /* since we don't need any more endpoints that come from v */
} else {
IGRAPH_CHECK(igraph_dqueue_long_push(&q, w));
VECTOR(parent)[w] = u;
}
IGRAPH_CHECK(igraph_vector_push_back(&vec1, w));
}
/* Now do the same with the phantom edges */
neis2 = igraph_adjlist_get(&tight_phantom_edges, v);
n = igraph_vector_int_size(neis2);
for (i = 0; i < n; i++) {
u = (igraph_integer_t) VECTOR(*neis2)[i];
/* Have we seen u already? */
if (VECTOR(parent)[u] >= 0)
continue;
/* Check if the edge is really tight; it might have happened that the
* edge became non-tight in the meanwhile. We do not remove these from
* tight_phantom_edges at the moment, so we check them once again here.
*/
if (fabs(VECTOR(labels)[(long int)v] + VECTOR(labels)[(long int)u]) > eps)
continue;
debug(" Reached vertex %ld via tight phantom edge\n", (long)u);
VECTOR(parent)[u] = v;
IGRAPH_CHECK(igraph_vector_push_back(&vec2, u));
w = (int) VECTOR(match)[u];
if (w == -1) {
/* u is unmatched and it is in the larger set. Therefore, we
* could improve the matching by following the parents back
* from u to the root.
*/
alternating_path_endpoint = u;
break; /* since we don't need any more endpoints that come from v */
} else {
IGRAPH_CHECK(igraph_dqueue_long_push(&q, w));
VECTOR(parent)[w] = u;
}
IGRAPH_CHECK(igraph_vector_push_back(&vec1, w));
}
}
/* Okay; did we have an alternating path? */
if (alternating_path_endpoint != -1) {
#ifdef MATCHING_DEBUG
debug("BFS parent tree:");
igraph_vector_print(&parent);
#endif
/* Increase the size of the matching with the alternating path. */
v = alternating_path_endpoint;
u = (igraph_integer_t) VECTOR(parent)[v];
debug("Extending matching with alternating path ending in %ld.\n", (long int)v);
while (u != v) {
w = (int) VECTOR(match)[v];
if (w != -1)
VECTOR(match)[w] = -1;
VECTOR(match)[v] = u;
VECTOR(match)[v] = u;
w = (int) VECTOR(match)[u];
if (w != -1)
VECTOR(match)[w] = -1;
VECTOR(match)[u] = v;
v = (igraph_integer_t) VECTOR(parent)[u];
u = (igraph_integer_t) VECTOR(parent)[v];
}
msize++;
#ifdef MATCHING_DEBUG
debug("New matching after update:");
igraph_vector_long_print(&match);
debug("Matching size is now: %ld\n", (long)msize);
#endif
continue;
}
#ifdef MATCHING_DEBUG
debug("Vertices reachable from unmatched ones via tight edges:\n");
igraph_vector_print(&vec1);
igraph_vector_print(&vec2);
#endif
/* At this point, vec1 contains the nodes in the smaller set (A)
* reachable from unmatched nodes in A via tight edges only, while vec2
* contains the nodes in the larger set (B) reachable from unmatched
* nodes in A via tight edges only. Also, parent[i] >= 0 if node i
* is reachable */
/* Check the edges between reachable nodes in A and unreachable
* nodes in B, and find the minimum slack on them.
*
* Since the weights are positive, we do no harm if we first
* assume that there are no "real" edges between the two sets
* mentioned above and determine an upper bound for min_slack
* based on this. */
min_slack = IGRAPH_INFINITY;
min_slack_u = min_slack_v = 0;
n = igraph_vector_size(&vec1);
for (i = 0; i < no_of_nodes; i++) {
if (VECTOR(*types)[i] == smaller_set)
continue;
if (VECTOR(labels)[i] < min_slack) {
min_slack = VECTOR(labels)[i];
min_slack_v = (igraph_integer_t) i;
}
}
min_slack_2 = IGRAPH_INFINITY;
for (i = 0; i < n; i++) {
u = (igraph_integer_t) VECTOR(vec1)[i];
/* u is surely from the smaller set, but we are interested in it
* only if it is reachable from an unmatched vertex */
if (VECTOR(parent)[u] < 0)
continue;
if (VECTOR(labels)[u] < min_slack_2) {
min_slack_2 = VECTOR(labels)[u];
min_slack_u = u;
}
}
min_slack += min_slack_2;
debug("Starting approximation for min_slack = %.4f (based on vertex pair %ld--%ld)\n",
min_slack, (long int)min_slack_u, (long int)min_slack_v);
n = igraph_vector_size(&vec1);
for (i = 0; i < n; i++) {
u = (igraph_integer_t) VECTOR(vec1)[i];
/* u is a reachable node in A; get its incident edges.
*
* There are two types of incident edges: 1) real edges,
* 2) phantom edges. Phantom edges were treated earlier
* when we determined the initial value for min_slack. */
debug("Trying to expand along vertex %ld\n", (long int)u);
neis = igraph_inclist_get(&inclist, u);
k = igraph_vector_size(neis);
for (j = 0; j < k; j++) {
/* v is the vertex sitting at the other end of an edge incident
* on u; check whether it was reached */
v = IGRAPH_OTHER(graph, VECTOR(*neis)[j], u);
debug(" Edge %ld -- %ld (ID=%ld)\n", (long int)u, (long int)v, (long int)VECTOR(*neis)[j]);
if (VECTOR(parent)[v] >= 0) {
/* v was reached, so we are not interested in it */
debug(" %ld was reached, so we are not interested in it\n", (long int)v);
continue;
}
/* v is the ID of the edge from now on */
v = (igraph_integer_t) VECTOR(*neis)[j];
if (VECTOR(slack)[v] < min_slack) {
min_slack = VECTOR(slack)[v];
min_slack_u = u;
min_slack_v = IGRAPH_OTHER(graph, v, u);
}
debug(" Slack of this edge: %.4f, min slack is now: %.4f\n",
VECTOR(slack)[v], min_slack);
}
}
debug("Minimum slack: %.4f on edge %d--%d\n", min_slack, (int)min_slack_u, (int)min_slack_v);
if (min_slack > 0) {
/* Decrease the label of reachable nodes in A by min_slack.
* Also update the dual solution */
n = igraph_vector_size(&vec1);
for (i = 0; i < n; i++) {
u = (igraph_integer_t) VECTOR(vec1)[i];
VECTOR(labels)[u] -= min_slack;
neis = igraph_inclist_get(&inclist, u);
k = igraph_vector_size(neis);
for (j = 0; j < k; j++) {
debug(" Decreasing slack of edge %ld (%ld--%ld) by %.4f\n",
(long)VECTOR(*neis)[j], (long)u,
(long)IGRAPH_OTHER(graph, VECTOR(*neis)[j], u), min_slack);
VECTOR(slack)[(long int)VECTOR(*neis)[j]] -= min_slack;
}
dual -= min_slack;
}
/* Increase the label of reachable nodes in B by min_slack.
* Also update the dual solution */
n = igraph_vector_size(&vec2);
for (i = 0; i < n; i++) {
u = (igraph_integer_t) VECTOR(vec2)[i];
VECTOR(labels)[u] += min_slack;
neis = igraph_inclist_get(&inclist, u);
k = igraph_vector_size(neis);
for (j = 0; j < k; j++) {
debug(" Increasing slack of edge %ld (%ld--%ld) by %.4f\n",
(long)VECTOR(*neis)[j], (long)u,
(long)IGRAPH_OTHER(graph, (long)VECTOR(*neis)[j], u), min_slack);
VECTOR(slack)[(long int)VECTOR(*neis)[j]] += min_slack;
}
dual += min_slack;
}
}
/* Update the set of tight phantom edges.
* Note that we must do it even if min_slack is zero; the reason is that
* it can happen that min_slack is zero in the first step if there are
* isolated nodes in the input graph.
*
* TODO: this is O(n^2) here. Can we do it faster? */
for (u = 0; u < no_of_nodes; u++) {
if (VECTOR(*types)[u] != smaller_set)
continue;
for (v = 0; v < no_of_nodes; v++) {
if (VECTOR(*types)[v] == smaller_set)
continue;
if (VECTOR(labels)[(long int)u] + VECTOR(labels)[(long int)v] <= eps) {
/* Tight phantom edge found. Note that we don't have to check whether
* u and v are connected; if they were, then the slack of this edge
* would be negative. */
neis2 = igraph_adjlist_get(&tight_phantom_edges, u);
if (!igraph_vector_int_binsearch(neis2, v, &i)) {
debug("New tight phantom edge: %ld -- %ld\n", (long)u, (long)v);
IGRAPH_CHECK(igraph_vector_int_insert(neis2, i, v));
}
}
}
}
#ifdef MATCHING_DEBUG
debug("New labels:");
igraph_vector_print(&labels);
debug("Slacks after updating with min_slack:");
igraph_vector_print(&slack);
#endif
}
/* Cleanup: remove phantom edges from the matching */
for (i = 0; i < no_of_nodes; i++) {
if (VECTOR(*types)[i] != smaller_set)
continue;
if (VECTOR(match)[i] != -1) {
j = VECTOR(match)[i];
neis2 = igraph_adjlist_get(&tight_phantom_edges, i);
if (igraph_vector_int_binsearch(neis2, j, 0)) {
VECTOR(match)[i] = VECTOR(match)[j] = -1;
msize--;
}
}
}
/* Fill the output parameters */
if (matching != 0) {
IGRAPH_CHECK(igraph_vector_long_update(matching, &match));
}
if (matching_size != 0) {
*matching_size = msize;
}
if (matching_weight != 0) {
*matching_weight = 0;
for (i = 0; i < no_of_edges; i++) {
if (IS_TIGHT(i)) {
IGRAPH_CHECK(igraph_edge(graph, (igraph_integer_t) i, &u, &v));
if (VECTOR(match)[u] == v)
*matching_weight += VECTOR(*weights)[i];
}
}
}
/* Release everything */
#undef IS_TIGHT
igraph_inclist_destroy(&inclist);
igraph_adjlist_destroy(&tight_phantom_edges);
igraph_vector_destroy(&parent);
igraph_dqueue_long_destroy(&q);
igraph_vector_destroy(&labels);
igraph_vector_destroy(&vec1);
igraph_vector_destroy(&vec2);
igraph_vector_destroy(&slack);
igraph_vector_long_destroy(&match);
IGRAPH_FINALLY_CLEAN(9);
return IGRAPH_SUCCESS;
}