int main() {
igraph_t g;
igraph_vector_t y;
/* turn on attribute handling */
igraph_i_set_attribute_table(&igraph_cattribute_table);
/* Create a graph, add some attributes and save it as a GraphML file */
igraph_famous(&g, "Petersen");
SETGAS(&g, "name", "Petersen's graph");
SETGAN(&g, "vertices", igraph_vcount(&g));
SETGAN(&g, "edges", igraph_ecount(&g));
igraph_vector_init_seq(&y, 1, igraph_vcount(&g));
SETVANV(&g, "id", &y);
igraph_vector_destroy(&y);
SETVAS(&g, "name", 0, "foo");
SETVAS(&g, "name", 1, "foobar");
igraph_vector_init_seq(&y, 1, igraph_ecount(&g));
SETEANV(&g, "id", &y);
igraph_vector_destroy(&y);
SETEAS(&g, "name", 0, "FOO");
SETEAS(&g, "name", 1, "FOOBAR");
igraph_write_graph_gml(&g, stdout, 0, "");
igraph_write_graph_graphml(&g, stdout);
igraph_destroy(&g);
return 0;
}
igraph_bool_t check_laplacian(igraph_t* graph, igraph_matrix_t* matrix, igraph_vector_t* w) {
igraph_vector_t vec, res;
long int i, j;
igraph_vector_init(&vec, 0);
igraph_vector_init(&res, igraph_vcount(graph));
if (w)
igraph_strength(graph, &vec, igraph_vss_all(), IGRAPH_OUT, IGRAPH_NO_LOOPS, w);
else
igraph_degree(graph, &vec, igraph_vss_all(), IGRAPH_OUT, IGRAPH_NO_LOOPS);
for (i = 0; i < igraph_vcount(graph); i++) {
VECTOR(vec)[i] = sqrt(VECTOR(vec)[i]);
}
for (i = 0; i < igraph_vcount(graph); i++) {
for (j = 0; j < igraph_vcount(graph); j++) {
VECTOR(res)[i] += MATRIX(*matrix, i, j) * VECTOR(vec)[j];
}
}
if (igraph_vector_min(&res) > 1e-7) {
printf("Invalid Laplacian matrix:\n");
igraph_matrix_print(matrix);
return 0;
}
igraph_vector_destroy(&vec);
igraph_vector_destroy(&res);
return 1;
}
int check_ring_properties(const igraph_t *ring, igraph_bool_t directed,
igraph_bool_t mutual, igraph_bool_t circular) {
igraph_bool_t res;
/* Connected */
igraph_is_connected(ring, &res, IGRAPH_WEAK);
if (!res) {
printf("Not connected\n");
return 1;
}
/* Simple */
igraph_is_simple(ring, &res);
if (!res) {
printf("Not simple\n");
return 2;
}
/* Girth, for big enough circular graphs */
if (circular && igraph_vcount(ring) > 2) {
igraph_integer_t girth;
igraph_girth(ring, &girth, NULL);
if (girth != igraph_vcount(ring)) {
printf("Wrong girth\n");
return 3;
}
}
return 0;
}
int TMIgraph::readTopology(char *file_name) {
int ret;
Bitvector *lid;
Bitvector *ilid;
ifstream infile;
string str;
size_t found, first, second;
FILE *instream;
infile.open(file_name, ifstream::in);
/*first the Global graph attributes - c igraph does not do it!!*/
while (infile.good()) {
getline(infile, str);
found = str.find("<data key=\"FID_LEN\">");
if (found != string::npos) {
first = str.find(">");
second = str.find("<", first);
sscanf(str.substr(first + 1, second - first - 1).c_str(), "%d", &fid_len);
}
found = str.find("<data key=\"TM\">");
if (found != string::npos) {
first = str.find(">");
second = str.find("<", first);
nodeID = str.substr(first + 1, second - first - 1);
}
found = str.find("<data key=\"TM_MODE\">");
if (found != string::npos) {
first = str.find(">");
second = str.find("<", first);
mode = str.substr(first + 1, second - first - 1);
}
}
infile.close();
instream = fopen(file_name, "r");
ret = igraph_read_graph_graphml(&graph, instream, 0);
fclose(instream);
if (ret < 0) {
return ret;
}
cout << "TM: " << igraph_vcount(&graph) << " nodes" << endl;
cout << "TM: " << igraph_ecount(&graph) << " edges" << endl;
for (int i = 0; i < igraph_vcount(&graph); i++) {
string nID = string(igraph_cattribute_VAS(&graph, "NODEID", i));
string iLID = string(igraph_cattribute_VAS(&graph, "iLID", i));
reverse_node_index.insert(pair<string, int>(nID, i));
ilid = new Bitvector(iLID);
nodeID_iLID.insert(pair<string, Bitvector *>(nID, ilid));
vertex_iLID.insert(pair<int, Bitvector *>(i, ilid));
//cout << "node " << i << " has NODEID " << nID << endl;
//cout << "node " << i << " has ILID " << ilid->to_string() << endl;
}
for (int i = 0; i < igraph_ecount(&graph); i++) {
string LID = string(igraph_cattribute_EAS(&graph, "LID", i));
reverse_edge_index.insert(pair<string, int>(LID, i));
lid = new Bitvector(LID);
edge_LID.insert(pair<int, Bitvector *>(i, lid));
//cout << "edge " << i << " has LID " << lid->to_string() << endl;
}
return ret;
}
int igraph_local_scan_0_them(const igraph_t *us, const igraph_t *them,
igraph_vector_t *res,
const igraph_vector_t *weights_them,
igraph_neimode_t mode) {
igraph_t is;
if (igraph_vcount(us) != igraph_vcount(them)) {
IGRAPH_ERROR("Number of vertices don't match in scan-0", IGRAPH_EINVAL);
}
if (igraph_is_directed(us) != igraph_is_directed(them)) {
IGRAPH_ERROR("Directedness don't match in scan-0", IGRAPH_EINVAL);
}
if (weights_them) {
return igraph_i_local_scan_0_them_w(us, them, res, weights_them, mode);
}
igraph_intersection(&is, us, them, /*edgemap1=*/ 0, /*edgemap2=*/ 0);
IGRAPH_FINALLY(igraph_destroy, &is);
igraph_degree(&is, res, igraph_vss_all(), mode, IGRAPH_LOOPS);
igraph_destroy(&is);
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int main() {
igraph_t g;
igraph_vector_t v1, v2;
int ret;
/* simple use */
igraph_vector_init(&v1, 8);
VECTOR(v1)[0]=0; VECTOR(v1)[1]=1;
VECTOR(v1)[2]=1; VECTOR(v1)[3]=2;
VECTOR(v1)[4]=2; VECTOR(v1)[5]=3;
VECTOR(v1)[6]=2; VECTOR(v1)[7]=2;
igraph_create(&g, &v1, 0, 0);
if (igraph_vcount(&g) != 4) {
return 1;
}
igraph_vector_init(&v2, 0);
igraph_get_edgelist(&g, &v2, 0);
igraph_vector_sort(&v1);
igraph_vector_sort(&v2);
if (!igraph_vector_all_e(&v1, &v2)) {
return 2;
}
igraph_destroy(&g);
/* higher number of vertices */
igraph_create(&g, &v1, 10, 0);
if (igraph_vcount(&g) != 10) {
return 1;
}
igraph_get_edgelist(&g, &v2, 0);
igraph_vector_sort(&v1);
igraph_vector_sort(&v2);
if (!igraph_vector_all_e(&v1, &v2)) {
return 3;
}
igraph_destroy(&g);
/* error: IGRAPH_EINVEVECTOR */
igraph_set_error_handler(igraph_error_handler_ignore);
igraph_vector_resize(&v1, 9);
VECTOR(v1)[8]=0;
ret=igraph_create(&g, &v1, 0, 0);
if (ret != IGRAPH_EINVEVECTOR) {
return 4;
}
/* error: IGRAPH_EINVVID */
igraph_vector_resize(&v1, 8);
VECTOR(v1)[7]=-1;
ret=igraph_create(&g, &v1, 10, 1);
if (ret != IGRAPH_EINVVID) {
return 5;
}
igraph_vector_destroy(&v1);
igraph_vector_destroy(&v2);
return 0;
}
int main() {
igraph_t g;
int ret;
/* empty directed graph, zero vertices */
igraph_empty(&g, 0, 1);
if (igraph_vcount(&g) != 0) {
return 1;
}
if (igraph_ecount(&g) != 0) {
return 2;
}
igraph_destroy(&g);
/* empty undirected graph, zero vertices */
igraph_empty(&g, 0, 0);
if (igraph_vcount(&g) != 0) {
return 3;
}
if (igraph_ecount(&g) != 0) {
return 4;
}
igraph_destroy(&g);
/* empty directed graph, 20 vertices */
igraph_empty(&g, 20, 1);
if (igraph_vcount(&g) != 20) {
return 5;
}
if (igraph_ecount(&g) != 0) {
return 6;
}
igraph_destroy(&g);
/* empty undirected graph, 30 vertices */
igraph_empty(&g, 30, 0);
if (igraph_vcount(&g) != 30) {
return 7;
}
if (igraph_ecount(&g) != 0) {
return 8;
}
igraph_destroy(&g);
/* error: negative number of vertices */
igraph_set_error_handler(igraph_error_handler_ignore);
ret=igraph_empty(&g, -1, 0);
if (ret != IGRAPH_EINVAL) {
return 9;
}
return 0;
}
int main() {
igraph_t g;
igraph_vector_t v;
int ret;
/* without edges */
igraph_empty(&g, 5, IGRAPH_DIRECTED);
igraph_add_vertices(&g, 2, 0);
igraph_add_vertices(&g, 3, 0);
igraph_add_vertices(&g, 1, 0);
igraph_add_vertices(&g, 4, 0);
if (igraph_vcount(&g) != 15) {
return 1;
}
igraph_delete_vertices(&g, igraph_vss_1(2));
if (igraph_vcount(&g) != 14) {
return 2;
}
igraph_destroy(&g);
igraph_vector_init(&v, 8);
VECTOR(v)[0]=0; VECTOR(v)[1]=1;
VECTOR(v)[2]=1; VECTOR(v)[3]=2;
VECTOR(v)[4]=2; VECTOR(v)[5]=3;
VECTOR(v)[6]=2; VECTOR(v)[7]=2;
igraph_create(&g, &v, 0, 0);
igraph_vector_destroy(&v);
/* resize vector */
igraph_delete_vertices(&g, igraph_vss_1(2));
if (igraph_vcount(&g) != 3) {
return 3;
}
if (igraph_ecount(&g) != 1) {
return 4;
}
/* error test */
igraph_set_error_handler(igraph_error_handler_ignore);
ret=igraph_delete_vertices(&g, igraph_vss_1(3));
if (ret != IGRAPH_EINVVID) {
return 5;
}
igraph_destroy(&g);
return 0;
}
int igraph_adjlist_init(const igraph_t *graph, igraph_adjlist_t *al,
igraph_neimode_t mode) {
long int i;
if (mode != IGRAPH_IN && mode != IGRAPH_OUT && mode != IGRAPH_ALL) {
IGRAPH_ERROR("Cannot create adjlist view", IGRAPH_EINVMODE);
}
if (!igraph_is_directed(graph)) { mode=IGRAPH_ALL; }
al->length=igraph_vcount(graph);
al->adjs=igraph_Calloc(al->length, igraph_vector_t);
if (al->adjs == 0) {
IGRAPH_ERROR("Cannot create adjlist view", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_adjlist_destroy, al);
for (i=0; i<al->length; i++) {
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_vector_init(&al->adjs[i], 0));
IGRAPH_CHECK(igraph_neighbors(graph, &al->adjs[i], i, mode));
}
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
VALUE cIGraph_modularity(VALUE self, VALUE groups){
igraph_t *graph;
igraph_real_t value;
igraph_vector_t membership;
VALUE group;
int i,j;
Data_Get_Struct(self, igraph_t, graph);
igraph_vector_init(&membership,igraph_vcount(graph));
for(i=0;i<RARRAY_LEN(groups);i++){
group = RARRAY_PTR(groups)[i];
for(j=0;j<RARRAY_LEN(group);j++){
igraph_vector_set(&membership,
cIGraph_get_vertex_id(self,RARRAY_PTR(group)[j]),i);
}
}
igraph_modularity(graph,&membership,&value,NULL);
igraph_vector_destroy(&membership);
return rb_float_new(value);
}
int igraph_i_cliquer_callback(const igraph_t *graph,
igraph_integer_t min_size, igraph_integer_t max_size,
igraph_clique_handler_t *cliquehandler_fn, void *arg)
{
graph_t *g;
struct callback_data cd;
igraph_integer_t vcount = igraph_vcount(graph);
if (vcount == 0)
return IGRAPH_SUCCESS;
if (min_size <= 0) min_size = 1;
if (max_size <= 0) max_size = 0;
if (max_size > 0 && max_size < min_size)
IGRAPH_ERROR("max_size must not be smaller than min_size", IGRAPH_EINVAL);
igraph_to_cliquer(graph, &g);
IGRAPH_FINALLY(graph_free, g);
cd.handler = cliquehandler_fn;
cd.arg = arg;
igraph_cliquer_opt.user_data = &cd;
igraph_cliquer_opt.user_function = &callback_callback;
CLIQUER_INTERRUPTABLE(clique_unweighted_find_all(g, min_size, max_size, /* maximal= */ FALSE, &igraph_cliquer_opt));
graph_free(g);
IGRAPH_FINALLY_CLEAN(1);
return IGRAPH_SUCCESS;
}
int igraph_i_cliquer_cliques(const igraph_t *graph, igraph_vector_ptr_t *res,
igraph_integer_t min_size, igraph_integer_t max_size)
{
graph_t *g;
igraph_integer_t vcount = igraph_vcount(graph);
if (vcount == 0) {
igraph_vector_ptr_clear(res);
return IGRAPH_SUCCESS;
}
if (min_size <= 0) min_size = 1;
if (max_size <= 0) max_size = 0;
if (max_size > 0 && max_size < min_size)
IGRAPH_ERROR("max_size must not be smaller than min_size", IGRAPH_EINVAL);
igraph_to_cliquer(graph, &g);
IGRAPH_FINALLY(graph_free, g);
igraph_vector_ptr_clear(res);
igraph_cliquer_opt.user_data = res;
igraph_cliquer_opt.user_function = &collect_cliques_callback;
IGRAPH_FINALLY(free_clique_list, res);
CLIQUER_INTERRUPTABLE(clique_unweighted_find_all(g, min_size, max_size, /* maximal= */ FALSE, &igraph_cliquer_opt));
IGRAPH_FINALLY_CLEAN(1);
graph_free(g);
IGRAPH_FINALLY_CLEAN(1);
return IGRAPH_SUCCESS;
}
/* call-seq:
* graph.get_adjacency(type) -> Array
*
* Returns the adjacency matrix of a graph
*
*/
VALUE cIGraph_get_adjacency(VALUE self, VALUE mode){
igraph_t *graph;
igraph_get_adjacency_t pmode = NUM2INT(mode);
igraph_matrix_t res;
int i;
int j;
VALUE row;
VALUE path_length;
VALUE matrix = rb_ary_new();
int n;
Data_Get_Struct(self, igraph_t, graph);
n = igraph_vcount(graph);
//matrix to hold the results of the calculations
igraph_matrix_init(&res,n,n);
igraph_get_adjacency(graph,&res,pmode);
for(i=0; i<igraph_matrix_nrow(&res); i++){
row = rb_ary_new();
rb_ary_push(matrix,row);
for(j=0; j<igraph_matrix_ncol(&res); j++){
path_length = INT2NUM(MATRIX(res,i,j));
rb_ary_push(row,path_length);
}
}
igraph_matrix_destroy(&res);
return matrix;
}
static inline void
rvine_tree_cleanup(igraph_t *tree)
{
igraph_integer_t e, a;
for (a = 0; a < igraph_vcount(tree); a++) {
if (VAP(tree, "h", a) != VAP(tree, "hrev", a)) {
gsl_vector_free(VAP(tree, "h", a));
gsl_vector_free(VAP(tree, "hrev", a));
gsl_permutation_free(VAP(tree, "hrank", a));
gsl_permutation_free(VAP(tree, "hrevrank", a));
} else if (VAP(tree, "h", a) != NULL) {
gsl_vector_free(VAP(tree, "h", a));
gsl_permutation_free(VAP(tree, "hrank", a));
} else {
gsl_vector_free(VAP(tree, "hrev", a));
gsl_permutation_free(VAP(tree, "hrevrank", a));
}
}
DELVAS(tree);
for (e = 0; e < igraph_ecount(tree); e++) {
gsl_vector_short_free(EAP(tree, "Ue", e));
dml_measure_free(EAP(tree, "measure", e));
}
DELEA(tree, "Ue");
DELEA(tree, "weight");
DELEA(tree, "measure");
}
void dump_graph(const char* header, const igraph_t* g) {
fputs(header, stdout);
printf("Vertices: %li\n", (long int) igraph_vcount(g));
printf("Edges: %li\n", (long int) igraph_ecount(g));
printf("Directed: %i\n", (int) igraph_is_directed(g));
igraph_write_graph_edgelist(g, stdout);
}
int igraph_is_separator(const igraph_t *graph,
const igraph_vs_t candidate,
igraph_bool_t *res) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_bool_t removed;
igraph_dqueue_t Q;
igraph_vector_t neis;
igraph_vit_t vit;
IGRAPH_CHECK(igraph_vit_create(graph, candidate, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
IGRAPH_CHECK(igraph_vector_bool_init(&removed, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &removed);
IGRAPH_CHECK(igraph_dqueue_init(&Q, 100));
IGRAPH_FINALLY(igraph_dqueue_destroy, &Q);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
IGRAPH_CHECK(igraph_i_is_separator(graph, &vit, -1, res, &removed,
&Q, &neis, no_of_nodes));
igraph_vector_destroy(&neis);
igraph_dqueue_destroy(&Q);
igraph_vector_bool_destroy(&removed);
igraph_vit_destroy(&vit);
IGRAPH_FINALLY_CLEAN(4);
return 0;
}
int igraph_i_largest_weighted_cliques(const igraph_t *graph,
const igraph_vector_t *vertex_weights, igraph_vector_ptr_t *res)
{
graph_t *g;
igraph_integer_t vcount = igraph_vcount(graph);
if (vcount == 0) {
igraph_vector_ptr_clear(res);
return IGRAPH_SUCCESS;
}
igraph_to_cliquer(graph, &g);
IGRAPH_FINALLY(graph_free, g);
IGRAPH_CHECK(set_weights(vertex_weights, g));
igraph_vector_ptr_clear(res);
igraph_cliquer_opt.user_data = res;
igraph_cliquer_opt.user_function = &collect_cliques_callback;
IGRAPH_FINALLY(free_clique_list, res);
CLIQUER_INTERRUPTABLE(clique_find_all(g, 0, 0, FALSE, &igraph_cliquer_opt));
IGRAPH_FINALLY_CLEAN(1);
graph_free(g);
IGRAPH_FINALLY_CLEAN(1);
return IGRAPH_SUCCESS;
}
int igraph_inclist_init(const igraph_t *graph,
igraph_inclist_t *il,
igraph_neimode_t mode) {
long int i;
if (mode != IGRAPH_IN && mode != IGRAPH_OUT && mode != IGRAPH_ALL) {
IGRAPH_ERROR("Cannot create incidence list view", IGRAPH_EINVMODE);
}
if (!igraph_is_directed(graph)) { mode=IGRAPH_ALL; }
il->length=igraph_vcount(graph);
il->incs=igraph_Calloc(il->length, igraph_vector_t);
if (il->incs == 0) {
IGRAPH_ERROR("Cannot create incidence list view", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_inclist_destroy, il);
for (i=0; i<il->length; i++) {
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_vector_init(&il->incs[i], 0));
IGRAPH_CHECK(igraph_incident(graph, &il->incs[i], i, mode));
}
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int igraph_i_weighted_clique_number(const igraph_t *graph,
const igraph_vector_t *vertex_weights, igraph_real_t *res)
{
graph_t *g;
igraph_integer_t vcount = igraph_vcount(graph);
if (vcount == 0) {
*res = 0;
return IGRAPH_SUCCESS;
}
igraph_to_cliquer(graph, &g);
IGRAPH_FINALLY(graph_free, g);
IGRAPH_CHECK(set_weights(vertex_weights, g));
igraph_cliquer_opt.user_function = NULL;
/* we are not using a callback function, thus this is not interruptable */
*res = clique_max_weight(g, &igraph_cliquer_opt);
graph_free(g);
IGRAPH_FINALLY_CLEAN(1);
return IGRAPH_SUCCESS;
}
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;
}
/**
* \function igraph_maximum_bipartite_matching
* Calculates a maximum matching in a bipartite graph.
*
* A matching in a bipartite graph is a partial assignment of vertices
* of the first kind to vertices of the second kind such that each vertex of
* the first kind is matched to at most one vertex of the second kind and
* vice versa, and matched vertices must be connected by an edge in the graph.
* The size (or cardinality) of a matching is the number of edges.
* A matching is a maximum matching if there exists no other matching with
* larger cardinality. For weighted graphs, a maximum matching is a matching
* whose edges have the largest possible total weight among all possible
* matchings.
*
* </para><para>
* Maximum matchings in bipartite graphs are found by the push-relabel algorithm
* with greedy initialization and a global relabeling after every n/2 steps where
* n is the number of vertices in the graph.
*
* </para><para>
* References: Cherkassky BV, Goldberg AV, Martin P, Setubal JC and Stolfi J:
* Augment or push: A computational study of bipartite matching and
* unit-capacity flow algorithms. ACM Journal of Experimental Algorithmics 3,
* 1998.
*
* </para><para>
* Kaya K, Langguth J, Manne F and Ucar B: Experiments on push-relabel-based
* maximum cardinality matching algorithms for bipartite graphs. Technical
* Report TR/PA/11/33 of the Centre Europeen de Recherche et de Formation
* Avancee en Calcul Scientifique, 2011.
*
* \param graph The input graph. It can be directed but the edge directions
* will be ignored.
* \param types Boolean vector giving the vertex types of the graph.
* \param matching_size The size of the matching (i.e. the number of matched
* vertex pairs will be returned here). It may be \c NULL
* if you don't need this.
* \param matching_weight The weight of the matching if the edges are weighted,
* or the size of the matching again if the edges are
* unweighted. It may be \c NULL if you don't need this.
* \param matching The matching itself. It must be a vector where element i
* contains the ID of the vertex that vertex i is matched to,
* or -1 if vertex i is unmatched.
* \param weights A null pointer (=no edge weights), or a vector giving the
* weights of the edges. Note that the algorithm is stable
* only for integer weights.
* \param eps A small real number used in equality tests in the weighted
* bipartite matching algorithm. Two real numbers are considered
* equal in the algorithm if their difference is smaller than
* \c eps. This is required to avoid the accumulation of numerical
* errors. It is advised to pass a value derived from the
* \c DBL_EPSILON constant in \c float.h here. If you are
* running the algorithm with no \c weights vector, this argument
* is ignored.
* \return Error code.
*
* Time complexity: O(sqrt(|V|) |E|) for unweighted graphs (according to the
* technical report referenced above), O(|V||E|) for weighted graphs.
*
* \example examples/simple/igraph_maximum_bipartite_matching.c
*/
int igraph_maximum_bipartite_matching(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) {
/* Sanity checks */
if (igraph_vector_bool_size(types) < igraph_vcount(graph)) {
IGRAPH_ERROR("types vector too short", IGRAPH_EINVAL);
}
if (weights && igraph_vector_size(weights) < igraph_ecount(graph)) {
IGRAPH_ERROR("weights vector too short", IGRAPH_EINVAL);
}
if (weights == 0) {
IGRAPH_CHECK(igraph_i_maximum_bipartite_matching_unweighted(graph, types,
matching_size, matching));
if (matching_weight != 0) {
*matching_weight = *matching_size;
}
return IGRAPH_SUCCESS;
} else {
return igraph_i_maximum_bipartite_matching_weighted(graph, types,
matching_size, matching_weight, matching, weights, eps);
}
}
int igraph_similarity_inverse_log_weighted(const igraph_t *graph,
igraph_matrix_t *res, const igraph_vs_t vids, igraph_neimode_t mode) {
igraph_vector_t weights;
igraph_neimode_t mode0;
long int i, no_of_nodes;
switch (mode) {
case IGRAPH_OUT: mode0 = IGRAPH_IN; break;
case IGRAPH_IN: mode0 = IGRAPH_OUT; break;
default: mode0 = IGRAPH_ALL;
}
no_of_nodes = igraph_vcount(graph);
IGRAPH_VECTOR_INIT_FINALLY(&weights, no_of_nodes);
IGRAPH_CHECK(igraph_degree(graph, &weights, igraph_vss_all(), mode0, 1));
for (i=0; i < no_of_nodes; i++) {
if (VECTOR(weights)[i] > 1)
VECTOR(weights)[i] = 1.0 / log(VECTOR(weights)[i]);
}
IGRAPH_CHECK(igraph_cocitation_real(graph, res, vids, mode0, &weights));
igraph_vector_destroy(&weights);
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int igraph_i_local_scan_1_directed(const igraph_t *graph,
igraph_vector_t *res,
const igraph_vector_t *weights,
igraph_neimode_t mode) {
int no_of_nodes=igraph_vcount(graph);
igraph_inclist_t incs;
int i, node;
igraph_vector_int_t neis;
IGRAPH_CHECK(igraph_inclist_init(graph, &incs, mode));
IGRAPH_FINALLY(igraph_inclist_destroy, &incs);
igraph_vector_int_init(&neis, no_of_nodes);
IGRAPH_FINALLY(igraph_vector_int_destroy, &neis);
igraph_vector_resize(res, no_of_nodes);
igraph_vector_null(res);
for (node=0; node < no_of_nodes; node++) {
igraph_vector_int_t *edges1=igraph_inclist_get(&incs, node);
int edgeslen1=igraph_vector_int_size(edges1);
IGRAPH_ALLOW_INTERRUPTION();
/* Mark neighbors and self*/
VECTOR(neis)[node] = node+1;
for (i=0; i<edgeslen1; i++) {
int e=VECTOR(*edges1)[i];
int nei=IGRAPH_OTHER(graph, e, node);
igraph_real_t w= weights ? VECTOR(*weights)[e] : 1;
VECTOR(neis)[nei] = node+1;
VECTOR(*res)[node] += w;
}
/* Crawl neighbors */
for (i=0; i<edgeslen1; i++) {
int e2=VECTOR(*edges1)[i];
int nei=IGRAPH_OTHER(graph, e2, node);
igraph_vector_int_t *edges2=igraph_inclist_get(&incs, nei);
int j, edgeslen2=igraph_vector_int_size(edges2);
for (j=0; j<edgeslen2; j++) {
int e2=VECTOR(*edges2)[j];
int nei2=IGRAPH_OTHER(graph, e2, nei);
igraph_real_t w2= weights ? VECTOR(*weights)[e2] : 1;
if (VECTOR(neis)[nei2] == node+1) {
VECTOR(*res)[node] += w2;
}
}
}
} /* node < no_of_nodes */
igraph_vector_int_destroy(&neis);
igraph_inclist_destroy(&incs);
IGRAPH_FINALLY_CLEAN(2);
return 0;
}
int igraph_get_eid2(const igraph_t *graph, igraph_integer_t *eid,
igraph_integer_t pfrom, igraph_integer_t pto,
igraph_bool_t directed) {
long int from=pfrom, to=pto;
long int nov=igraph_vcount(graph);
if (from < 0 || to < 0 || from > nov-1 || to > nov-1) {
IGRAPH_ERROR("cannot get edge id", IGRAPH_EINVVID);
}
*eid=-1;
if (igraph_is_directed(graph)) {
/* Directed graph */
FIND_DIRECTED_EDGE(graph,from,to,eid);
if (!directed && *eid < 0) {
FIND_DIRECTED_EDGE(graph,to,from,eid);
}
} else {
/* Undirected graph, they only have one mode */
FIND_UNDIRECTED_EDGE(graph,from,to,eid);
}
return IGRAPH_SUCCESS;
}
int main() {
igraph_t g;
igraph_integer_t result;
igraph_vector_t edges, res;
igraph_vs_t vids;
long i, n;
igraph_tree(&g, 10, 3, IGRAPH_TREE_OUT);
igraph_rewire(&g, 1000, IGRAPH_REWIRING_SIMPLE);
n=igraph_vcount(&g);
igraph_vector_init(&res, 0);
igraph_degree(&g, &res, igraph_vss_all(), IGRAPH_IN, 0);
for (i=0; i<n; i++)
printf("%ld ", (long)igraph_vector_e(&res, i));
printf("\n");
igraph_degree(&g, &res, igraph_vss_all(), IGRAPH_OUT, 0);
for (i=0; i<n; i++)
printf("%ld ", (long)igraph_vector_e(&res, i));
printf("\n");
igraph_destroy(&g);
igraph_vector_destroy(&res);
return 0;
}
int GraphRepresentation::buildIGraphTopology() {
int source_vertex_id, destination_vertex_id;
igraph_i_set_attribute_table(&igraph_cattribute_table);
igraph_empty(&igraph, 0, true);
//cout << "iGraph: number of nodes: " << dm->number_of_nodes << endl;
//cout << "iGraph: number number_of_connections nodes: " << dm->number_of_connections << endl;
for (int i = 0; i < dm->network_nodes.size(); i++) {
NetworkNode *nn = dm->network_nodes[i];
for (int j = 0; j < nn->connections.size(); j++) {
NetworkConnection *nc = nn->connections[j];
map <string, int>::iterator index_it;
/*find that node - if exists*/
index_it = reverse_node_index.find(nc->src_label);
/*check if the source node exists in the reverse index*/
if (index_it == reverse_node_index.end()) {
/*it does not exist...add it*/
source_vertex_id = igraph_vcount(&igraph);
igraph_add_vertices(&igraph, 1, 0);
reverse_node_index.insert(pair<string, int>(nc->src_label, source_vertex_id));
igraph_cattribute_VAS_set(&igraph, "NODEID", source_vertex_id, nc->src_label.c_str());
//cout << "added node " << nc->src_label << " in the igraph" << endl;
} else {
source_vertex_id = (*index_it).second;
}
index_it = reverse_node_index.find(nc->dst_label);
/*check if the destination node exists in the reverse index*/
if (index_it == reverse_node_index.end()) {
/*it does not exist...add it*/
destination_vertex_id = igraph_vcount(&igraph);
igraph_add_vertices(&igraph, 1, 0);
reverse_node_index.insert(pair<string, int>(nc->dst_label, destination_vertex_id));
igraph_cattribute_VAS_set(&igraph, "NODEID", destination_vertex_id, nc->dst_label.c_str());
//cout << "added node " << nc->dst_label << " in the igraph" << endl;
} else {
destination_vertex_id = (*index_it).second;
}
/*add an edge in the graph*/
igraph_add_edge(&igraph, source_vertex_id, destination_vertex_id);
igraph_cattribute_EAS_set(&igraph, "LID", igraph_ecount(&igraph) - 1, nc->LID.to_string().c_str());
reverse_edge_index.insert(pair<string, int>(nc->LID.to_string(), igraph_ecount(&igraph) - 1));
}
}
for (int i = 0; i < dm->network_nodes.size(); i++) {
NetworkNode *nn = dm->network_nodes[i];
igraph_cattribute_VAS_set(&igraph, "iLID", i, nn->iLid.to_string().c_str());
}
}
int main() {
igraph_t g;
/* long int i; */
/* struct tms time; */
/* clock_t current_time,start_time; */
/* long int runs=100, n=10000; */
/* igraph_real_t r=0.01; */
/* Empty graph */
igraph_grg_game(&g, 100, 0, 0, 0, 0);
if (igraph_ecount(&g) != 0) {
return 1;
}
igraph_destroy(&g);
/* Full graph */
igraph_grg_game(&g, 10, sqrt(2.0)/2, 1, 0, 0);
if (igraph_ecount(&g) != igraph_vcount(&g) * (igraph_vcount(&g)-1)/2) {
return 2;
}
igraph_destroy(&g);
/* Measure running time */
/* tps=sysconf(_SC_CLK_TCK); // clock ticks per second */
/* times(&time); start_time=time.tms_utime; */
/* for (i=0; i<runs; i++) { */
/* igraph_grg_game2(&g, n, r, 1); */
/* igraph_destroy(&g); */
/* } */
/* times(&time); current_time=time.tms_utime; */
/* fprintf(stdout," sorted: time=%.3fs\n",(current_time-start_time)/(double)tps); */
/* tps=sysconf(_SC_CLK_TCK); // clock ticks per second */
/* times(&time); start_time=time.tms_utime; */
/* for (i=0; i<runs; i++) { */
/* igraph_grg_game(&g, n, r, 1); */
/* igraph_destroy(&g); */
/* } */
/* times(&time); current_time=time.tms_utime; */
/* fprintf(stdout,"non-sorted: time=%.3fs\n", */
/* (current_time-start_time)/(double)tps); */
return 0;
}
/**
* \ingroup python_interface_vertexseq
* \brief Initialize a new vertex sequence object for a given graph
* \return the initialized PyObject
*/
int igraphmodule_VertexSeq_init(igraphmodule_VertexSeqObject *self,
PyObject *args, PyObject *kwds) {
static char *kwlist[] = { "graph", "vertices", NULL };
PyObject *g, *vsobj=Py_None;
igraph_vs_t vs;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|O", kwlist,
&igraphmodule_GraphType, &g, &vsobj))
return -1;
if (vsobj == Py_None) {
/* If vs is None, we are selecting all the vertices */
igraph_vs_all(&vs);
} else if (PyInt_Check(vsobj)) {
/* We selected a single vertex */
long int idx = PyInt_AsLong(vsobj);
if (idx < 0 || idx >= igraph_vcount(&((igraphmodule_GraphObject*)g)->g)) {
PyErr_SetString(PyExc_ValueError, "vertex index out of range");
return -1;
}
igraph_vs_1(&vs, (igraph_integer_t)idx);
} else {
igraph_vector_t v;
igraph_integer_t n = igraph_vcount(&((igraphmodule_GraphObject*)g)->g);
if (igraphmodule_PyObject_to_vector_t(vsobj, &v, 1))
return -1;
if (!igraph_vector_isininterval(&v, 0, n-1)) {
igraph_vector_destroy(&v);
PyErr_SetString(PyExc_ValueError, "vertex index out of range");
return -1;
}
if (igraph_vs_vector_copy(&vs, &v)) {
igraphmodule_handle_igraph_error();
igraph_vector_destroy(&v);
return -1;
}
igraph_vector_destroy(&v);
}
self->vs = vs;
Py_INCREF(g);
self->gref = (igraphmodule_GraphObject*)g;
return 0;
}
int igraph_i_cb_components(igraph_t *graph,
const igraph_vector_bool_t *excluded,
igraph_vector_long_t *components,
long int *no,
/* working area follows */
igraph_vector_long_t *compid,
igraph_dqueue_t *Q,
igraph_vector_t *neis) {
long int no_of_nodes=igraph_vcount(graph);
long int i;
long int cno=0;
igraph_vector_long_clear(components);
igraph_dqueue_clear(Q);
IGRAPH_CHECK(igraph_vector_long_resize(compid, no_of_nodes));
igraph_vector_long_null(compid);
for (i=0; i<no_of_nodes; i++) {
if (VECTOR(*compid)[i]) { continue; }
if (VECTOR(*excluded)[i]) { continue; }
IGRAPH_CHECK(igraph_dqueue_push(Q, i));
IGRAPH_CHECK(igraph_vector_long_push_back(components, i));
VECTOR(*compid)[i] = ++cno;
while (!igraph_dqueue_empty(Q)) {
igraph_integer_t node=(igraph_integer_t) igraph_dqueue_pop(Q);
long int j, n;
IGRAPH_CHECK(igraph_neighbors(graph, neis, node, IGRAPH_ALL));
n=igraph_vector_size(neis);
for (j=0; j<n; j++) {
long int v=(long int) VECTOR(*neis)[j];
if (VECTOR(*excluded)[v]) {
if (VECTOR(*compid)[v] != cno) {
VECTOR(*compid)[v] = cno;
IGRAPH_CHECK(igraph_vector_long_push_back(components, v));
}
} else {
if (!VECTOR(*compid)[v]) {
VECTOR(*compid)[v] = cno; /* could be anything positive */
IGRAPH_CHECK(igraph_vector_long_push_back(components, v));
IGRAPH_CHECK(igraph_dqueue_push(Q, v));
}
}
}
} /* while !igraph_dqueue_empty */
IGRAPH_CHECK(igraph_vector_long_push_back(components, -1));
} /* for i<no_of_nodes */
*no=cno;
return 0;
}
void dump_vertex_attribute_string(const char* name, const igraph_t* g) {
long int i, n = igraph_vcount(g);
printf("Vertex attribute '%s':", name);
for (i = 0; i < n; i++) {
printf(" %s", VAS(g, name, i));
}
printf("\n");
}
