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;
}
igraph_bool_t check_solution(const igraph_sparsemat_t *A,
const igraph_vector_t *x,
const igraph_vector_t *b) {
long int dim=igraph_vector_size(x);
igraph_vector_t res;
int j, p;
igraph_real_t min, max;
igraph_vector_copy(&res, b);
for (j=0; j<dim; j++) {
for (p=A->cs->p[j]; p < A->cs->p[j+1]; p++) {
long int from=A->cs->i[p];
igraph_real_t value=A->cs->x[p];
VECTOR(res)[from] -= VECTOR(*x)[j] * value;
}
}
igraph_vector_minmax(&res, &min, &max);
igraph_vector_destroy(&res);
return abs(min) < 1e-15 && abs(max) < 1e-15;
}
/* #include "igraph_visitor.h"
#include "igraph_memory.h"
#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_dqueue.h"
#include "igraph_stack.h"
#include "config.h"*/
int igraph_bfsr(const igraph_t *graph,
igraph_integer_t root,igraph_vector_t *roots,
igraph_neimode_t mode, igraph_bool_t unreachable,
const igraph_vector_t *restricted,
igraph_vector_t *order, igraph_vector_t *rank,
igraph_vector_t *father,
igraph_vector_t *pred, igraph_vector_t *succ,
igraph_vector_t *dist, igraph_bfshandler_t *callback,
void *extra) {
igraph_dqueue_t Q;
long int no_of_nodes=igraph_vcount(graph);
long int actroot=0;
igraph_vector_char_t added;
igraph_lazy_adjlist_t adjlist;
long int act_rank=0;
long int pred_vec=-1;
long int rootpos=0;
long int noroots= roots ? igraph_vector_size(roots) : 1;
if (!roots && (root < 0 || root >= no_of_nodes)) {
IGRAPH_ERROR("Invalid root vertex in BFS", IGRAPH_EINVAL);
}
if (roots) {
igraph_real_t min, max;
igraph_vector_minmax(roots, &min, &max);
if (min < 0 || max >= no_of_nodes) {
IGRAPH_ERROR("Invalid root vertex in BFS", IGRAPH_EINVAL);
}
}
if (restricted) {
igraph_real_t min, max;
igraph_vector_minmax(restricted, &min, &max);
if (min < 0 || max >= no_of_nodes) {
IGRAPH_ERROR("Invalid vertex id in restricted set", IGRAPH_EINVAL);
}
}
if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
mode != IGRAPH_ALL) {
IGRAPH_ERROR("Invalid mode argument", IGRAPH_EINVMODE);
}
if (!igraph_is_directed(graph)) { mode=IGRAPH_ALL; }
IGRAPH_CHECK(igraph_vector_char_init(&added, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_char_destroy, &added);
IGRAPH_CHECK(igraph_dqueue_init(&Q, 100));
IGRAPH_FINALLY(igraph_dqueue_destroy, &Q);
IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &adjlist, mode, /*simplify=*/ 0));
IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adjlist);
/* Mark the vertices that are not in the restricted set, as already
found. Special care must be taken for vertices that are not in
the restricted set, but are to be used as 'root' vertices. */
if (restricted) {
long int i, n=igraph_vector_size(restricted);
igraph_vector_char_fill(&added, 1);
for (i=0; i<n; i++) {
long int v=(long int) VECTOR(*restricted)[i];
VECTOR(added)[v]=0;
}
}
/* Resize result vectors, and fill them with IGRAPH_NAN */
# define VINIT(v) if (v) { \
igraph_vector_resize((v), no_of_nodes); \
igraph_vector_fill((v), IGRAPH_NAN); }
VINIT(order);
VINIT(rank);
VINIT(father);
VINIT(pred);
VINIT(succ);
VINIT(dist);
# undef VINIT
while (1) {
/* Get the next root vertex, if any */
if (roots && rootpos < noroots) {
/* We are still going through the 'roots' vector */
actroot=(long int) VECTOR(*roots)[rootpos++];
} else if (!roots && rootpos==0) {
/* We have a single root vertex given, and start now */
actroot=root;
rootpos++;
} else if (rootpos==noroots && unreachable) {
/* We finished the given root(s), but other vertices are also
tried as root */
actroot=0;
rootpos++;
} else if (unreachable && actroot+1 < no_of_nodes) {
/* We are already doing the other vertices, take the next one */
actroot++;
} else {
/* No more root nodes to do */
break;
}
/* OK, we have a new root, start BFS */
if (VECTOR(added)[actroot]) { continue; }
IGRAPH_CHECK(igraph_dqueue_push(&Q, actroot));
IGRAPH_CHECK(igraph_dqueue_push(&Q, 0));
VECTOR(added)[actroot] = 1;
if (father) { VECTOR(*father)[actroot] = -1; }
pred_vec=-1;
while (!igraph_dqueue_empty(&Q)) {
long int actvect=(long int) igraph_dqueue_pop(&Q);
long int actdist=(long int) igraph_dqueue_pop(&Q);
long int succ_vec;
igraph_vector_t *neis=igraph_lazy_adjlist_get(&adjlist,
(igraph_integer_t) actvect);
long int i, n=igraph_vector_size(neis);
if (pred) { VECTOR(*pred)[actvect] = pred_vec; }
if (rank) { VECTOR(*rank) [actvect] = act_rank; }
if (order) { VECTOR(*order)[act_rank++] = actvect; }
if (dist) { VECTOR(*dist)[actvect] = actdist; }
igraph_vector_shuffle(neis);
for (i=0; i<n; i++) {
long int nei=(long int) VECTOR(*neis)[i];
if (! VECTOR(added)[nei]) {
VECTOR(added)[nei] = 1;
IGRAPH_CHECK(igraph_dqueue_push(&Q, nei));
IGRAPH_CHECK(igraph_dqueue_push(&Q, actdist+1));
if (father) { VECTOR(*father)[nei] = actvect; }
}
}
succ_vec = igraph_dqueue_empty(&Q) ? -1L :
(long int) igraph_dqueue_head(&Q);
if (callback) {
igraph_bool_t terminate=
callback(graph, (igraph_integer_t) actvect, (igraph_integer_t)
pred_vec, (igraph_integer_t) succ_vec,
(igraph_integer_t) act_rank-1, (igraph_integer_t) actdist,
extra);
if (terminate) {
igraph_lazy_adjlist_destroy(&adjlist);
igraph_dqueue_destroy(&Q);
igraph_vector_char_destroy(&added);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
}
if (succ) { VECTOR(*succ)[actvect] = succ_vec; }
pred_vec=actvect;
} /* while Q !empty */
} /* for actroot < no_of_nodes */
igraph_lazy_adjlist_destroy(&adjlist);
igraph_dqueue_destroy(&Q);
igraph_vector_char_destroy(&added);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
int igraph_i_community_spinglass_negative(const igraph_t *graph,
const igraph_vector_t *weights,
igraph_real_t *modularity,
igraph_real_t *temperature,
igraph_vector_t *membership,
igraph_vector_t *csize,
igraph_integer_t spins,
igraph_bool_t parupdate,
igraph_real_t starttemp,
igraph_real_t stoptemp,
igraph_real_t coolfact,
igraph_spincomm_update_t update_rule,
igraph_real_t gamma,
/* igraph_matrix_t *adhesion, */
/* igraph_matrix_t *normalised_adhesion, */
/* igraph_real_t *polarization, */
igraph_real_t gamma_minus) {
unsigned long changes, runs;
igraph_bool_t use_weights=0;
bool zeroT;
double kT, acc;
ClusterList<NNode*> *cl_cur;
network *net;
PottsModelN *pm;
igraph_real_t d_n;
igraph_real_t d_p;
/* Check arguments */
if (parupdate) {
IGRAPH_ERROR("Parallel spin update not implemented with "
"negative gamma", IGRAPH_UNIMPLEMENTED);
}
if (spins < 2 || spins > 500) {
IGRAPH_ERROR("Invalid number of spins", IGRAPH_EINVAL);
}
if (update_rule != IGRAPH_SPINCOMM_UPDATE_SIMPLE &&
update_rule != IGRAPH_SPINCOMM_UPDATE_CONFIG) {
IGRAPH_ERROR("Invalid update rule", IGRAPH_EINVAL);
}
if (weights) {
if (igraph_vector_size(weights) != igraph_ecount(graph)) {
IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
}
use_weights=1;
}
if (coolfact < 0 || coolfact>=1.0) {
IGRAPH_ERROR("Invalid cooling factor", IGRAPH_EINVAL);
}
if (gamma < 0.0) {
IGRAPH_ERROR("Invalid gamma value", IGRAPH_EINVAL);
}
if (starttemp/stoptemp<1.0) {
IGRAPH_ERROR("starttemp should be larger in absolute value than stoptemp",
IGRAPH_EINVAL);
}
/* Check whether we have a single component */
igraph_bool_t conn;
IGRAPH_CHECK(igraph_is_connected(graph, &conn, IGRAPH_WEAK));
if (!conn) {
IGRAPH_ERROR("Cannot work with unconnected graph", IGRAPH_EINVAL);
}
igraph_vector_minmax(weights, &d_n, &d_p);
if (d_n > 0) { d_n=0; }
if (d_p < 0) { d_p=0; }
d_n = -d_n;
net = new network;
net->node_list =new DL_Indexed_List<NNode*>();
net->link_list =new DL_Indexed_List<NLink*>();
net->cluster_list=new DL_Indexed_List<ClusterList<NNode*>*>();
/* Transform the igraph_t */
IGRAPH_CHECK(igraph_i_read_network(graph, weights,
net, use_weights, 0));
bool directed = igraph_is_directed(graph);
pm=new PottsModelN(net,(unsigned int)spins, directed);
/* initialize the random number generator */
RNG_BEGIN();
if ((stoptemp==0.0) && (starttemp==0.0)) zeroT=true; else zeroT=false;
//Begin at a high enough temperature
kT=pm->FindStartTemp(gamma, gamma_minus, starttemp);
/* assign random initial configuration */
pm->assign_initial_conf(true);
runs=0;
changes=1;
acc = 0;
while (changes>0 && (kT/stoptemp>1.0 || (zeroT && runs<150)))
{
IGRAPH_ALLOW_INTERRUPTION(); /* This is not clean.... */
runs++;
kT = kT*coolfact;
acc=pm->HeatBathLookup(gamma, gamma_minus, kT, 50);
if (acc<(1.0-1.0/double(spins))*0.001)
changes=0;
else
changes=1;
} /* while loop */
/* These are needed, otherwise 'modularity' is not calculated */
igraph_matrix_t adhesion, normalized_adhesion;
igraph_real_t polarization;
IGRAPH_MATRIX_INIT_FINALLY(&adhesion, 0, 0);
IGRAPH_MATRIX_INIT_FINALLY(&normalized_adhesion, 0, 0);
pm->WriteClusters(modularity, temperature, csize, membership,
&adhesion, &normalized_adhesion, &polarization,
kT, d_p, d_n, gamma, gamma_minus);
igraph_matrix_destroy(&normalized_adhesion);
igraph_matrix_destroy(&adhesion);
IGRAPH_FINALLY_CLEAN(2);
while (net->link_list->Size()) delete net->link_list->Pop();
while (net->node_list->Size()) delete net->node_list->Pop();
while (net->cluster_list->Size())
{
cl_cur=net->cluster_list->Pop();
while (cl_cur->Size()) cl_cur->Pop();
delete cl_cur;
}
RNG_END();
return 0;
}
